import missing scripts

Ignore-this: 19b38d1fef5ab53c621485d19e0f539c

darcs-hash:20090208011652-f7719-88b91d404a04ff772ebf6033d5c6fa3344391410

Author: gwern

add.hs

@@ -0,0 +1,71 @@
+{-
+
+Here we have two examples of how we can define a abstract data type with a bunch
+of fields, serialize them to disk (using arbitrary Ints to represent each field)
+and then read them back in and restore the original list or whatevers of
+abstract data types.
+
+The question is, how can we turn functions into data which can be serialized
+this way?
+-}
+{- http://hpaste.org/4265 -}
+{-
+module Main (main)
+    where
+import Data.Binary
+data Math = Add | Subtract | Multiply
+    deriving Show
+
+eval :: (Num a) => Math -> a -> a -> a
+eval f = case f of
+           Add -> (+)
+           Subtract -> (-)
+           Multiply -> (*)
+
+instance Binary Math where
+      put Add = putWord8 0
+      put Subtract = putWord8 1
+      put Multiply = putWord8 2
+      get = do tag_ <- getWord8
+               case tag_ of
+                 0 -> return Add
+                 1 -> return Subtract
+                 2 -> return Multiply
+
+
+main = do encodeFile "tmp.s" [Add, Subtract, Multiply]
+          a <- decodeFile "tmp.s"
+          putStr $ show (a :: [Math])
+-}
+
+import Prelude hiding (reverse)
+import Data.Binary
+data STRING = Foldl | Flip | Colon | EmptyList
+    deriving Show
+
+-- eval :: (String a) => STRING -> a -> a -> a
+-- eval f = case f of
+--            Foldl -> (foldl1)
+--            Flip -> (flip)
+--            Colon -> (:)
+--            EmptyList -> ([])
+
+
+instance Binary STRING where
+       put Foldl = putWord8 0
+       put Flip = putWord8 1
+       put Colon = putWord8 2
+       put EmptyList = putWord8 3
+       get = do tag_ <- getWord8
+                case tag_ of
+                  0 -> return Foldl
+                  1 -> return Flip
+                  2 -> return Colon
+                  3 -> return EmptyList
+
+main = do print              [Foldl, Flip, Colon, EmptyList]
+          encodeFile "tmp.s" [Foldl, Flip, Colon, EmptyList]
+          a <- decodeFile "tmp.s"
+          print (a :: [STRING])
+
+-- foldl $ flip (:) []

fdupe.hs

@@ -0,0 +1,12 @@
+import Split (split)
+import Control.Monad (liftM)
+
+main :: IO ()
+main = do arg <- liftM (concat . map (fun . lines) . breakBlankLines) $ getContents
+          mapM_ putStrLn arg
+
+breakBlankLines :: String -> [String]
+breakBlankLines = map (\x -> if head x == '\n' then tail x else x) . filter (not . (==) "") . map concat . split (=="") . split (=='\n')
+
+fun :: [String] -> [String]
+fun strs = map (\x -> "ln -sf " ++ "\'" ++ (head strs) ++ "\' " ++ "\'" ++ x ++ "\'") $ tail strs

tmr.hs

@@ -0,0 +1,34 @@
+import Text.HTML.TagSoup.Render
+import Text.HTML.TagSoup
+
+main :: IO ()
+main = interact convertPre
+
+convertPre :: String -> String
+convertPre = renderNoQuoting . map convertToHaskell . canonicalizeTags . parseTags
+             where renderNoQuoting = renderTagsOptions (renderOptions{optEscape = (:[])})
+
+convertToHaskell :: Tag -> Tag
+convertToHaskell (TagOpen "pre" atts) = TagOpen "haskell" atts
+convertToHaskell (TagClose "pre") = TagClose "haskell"
+convertToHaskell x = x
+
+{- Parsec version from John MacFarlane:
+
+import Text.ParserCombinators.Parsec
+
+pPreHaskell = try $ do
+  string "<pre class=\"haskell\">"
+  body <- manyTill anyChar (try $ string "</pre>")
+  return $ "<haskell>" ++ body ++ "</haskell>"
+
+pOther = many (noneOf "<") <|> string "<"
+
+pDoc = many (pPreHaskell <|> pOther) >>= return . concat
+
+main = do
+  c <- getContents
+  case parse pDoc "" c of
+       Left err  -> error $ show err
+       Right res -> putStrLn res
+-}

uniq.hs

@@ -0,0 +1,10 @@
+module Main where
+import Control.Monad
+import Data.List
+import qualified Data.Set as Set
+
+main :: IO ()
+main = do files <- (liftM ((\h -> map (!!1) $ Set.toList $ Set.difference (Set.fromList $ i h) (j h))) $ getContents)
+          mapM_ (\x -> putStrLn $ "rm -f \'" ++ x ++ "\'") files
+                where i =  map words . sort . lines
+                      j = Set.fromList . nubBy (\x y -> head x == head y) . i