Revision as of 03:14, 28 February 2007
We need to start a GOOD (aka, not a PLEAC clone) Haskell cookbook.
This page is based on the Scheme Cookbook at http://schemecookbook.org/Cookbook/WebHome
A lot of functions are defined in the "Prelude". Also, if you ever want to search for a function, based on the name, type or module, take a look at the excellent Hoogle. This is for a lot of people a must-have while debugging and writing Haskell programs.
2.1 GHCi interaction
To start GHCi from a command prompt, simply type `ghci'
$ ghci ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. Prelude>
Prelude is the "base" library of Haskell.
To create variables at the GHCi prompt, use `let'
Prelude> let x = 5 Prelude> x 5 Prelude> let y = 3 Prelude> y 3 Prelude> x + y 8
To check the type of an expression or function, use the command `:t'
Prelude> :t x x :: Integer Prelude> :t "Hello" "Hello" :: [Char]
Haskell has the following types defined in the Standard Prelude.
Int -- bounded, word-sized integers Integer -- unbounded integers Double -- floating point values Char -- characters String -- equivalent to [Char], strings are lists of characters () -- the unit type Bool -- booleans [a] -- lists (a,b) -- tuples / product types Either a b -- sum types Maybe a -- optional values
Strings can be read as input using getLine.
Prelude> getLine Foo bar baz "Foo bar baz"
Strings can be output in a number of different ways.
Prelude> putStr "Foo" FooPrelude>
As you can see, putStr does not include the newline character `\n'. We can either use putStr like this:
Prelude> putStr "Foo\n" Foo
Or use putStrLn, which is already in the Standard Prelude
Prelude> putStrLn "Foo" Foo
We can also use print to print a string, including the quotation marks.
Prelude> print "Foo" "Foo"
Concatenation of strings (or any other list) is done with the `++' operator.
Prelude> "foo" ++ "bar" "foobar"
4.4 Regular expressions
Regular expressions are useful in some situations where the Data.List library is unwieldy. Posix style regular expressions are available in the core libraries, and a suite of other regular expression libraries are [also available], including PCRE and TRE-style regexes.
Bryan O'Sullivan has written a nice introduction to using the new regex libraries.
For high performance requirements (where you would typically consider C), consider using Data.ByteString.
4.7 Unicode (?)
5 NumbersNumbers in Haskell can be of the type
5.1 Random numbers
6 Dates and time
Use System.Time.getClockTime to get a properly formatted date stamp.
Prelude> System.Time.getClockTime Wed Feb 21 20:05:35 CST 2007
6.1 CPU time
Use System.CPUTime.getCPUTime to get the CPU time in picoseconds.
You can time a computation like this
getCPUTimeDouble :: IO Double getCPUTimeDouble = do t <- System.CPUTime.getCPUTime; return (fromInteger t) * 1e-12 main = do t1 <- getCPUTimeDouble print (fib 30) t2 <- getCPUTimeDouble print (t2-t1)
7 ListsIn Haskell, lists are what Arrays are in most other languages. Haskell has all of the general list manipulation functions, see also
Prelude> head [1,2,3] 1 Prelude> tail [1,2,3] [2,3] Prelude> length [1,2,3] 3
Furthermore, Haskell supports some neat concepts.
7.1 Infinite lists
The list of all squares:
square x = x*x squares = map square [1..]
Prelude> take 10 squares [1,4,9,16,25,36,49,64,81,100]
7.2 List comprehensions
The list of all squares can also be written in a more comprehensive way, using list comprehensions:
squares = [x*x | x <- [1..]]
8 Pattern matching
Haskell does implicit pattern matching.
A good example of pattern matching is done in the fact function for finding a factorial.
fact :: Integer -> Integer fact 0 = 1 fact n = n * fact (n - 1)
The 3rd and final line of this function is another pattern match, which says that, whatever number was entered as the argument, is multiplied by the factorial of that number, minus 1. Notice this function is recursive.Pattern matching in Haskell evaluates the patterns in the order they are written, so
9.1 Simple IOUsing
A program to sum up numbers:
main = interact $ show . sum . map read . lines
A program that adds line numbers to each line:
main = interact numberLines numberLines = unlines . zipWith combine [1..] . lines where combine lineNumber text = concat [show lineNumber, " ", text]
9.2 Reading from files
The System.IO library contains the functions needed for file IO. The program below displays the contents of the file c:\test.txt.
import System.IO main = do h <- openFile "c:\\test.txt" ReadMode contents <- hGetContents h putStrLn contents hClose h
The same program, with some higher-lever functions:
main = do contents <- readFile "c:\\test.txt" putStrLn contents
9.3 Writing to files
The following program writes the first 100 squares to a file:
-- generate a list of squares with length 'num' in string-format. numbers num = unlines $ take num $ map (show . \x -> x*x) [1..] main = do writeFile "test.txt" (numbers 100) putStrLn "successfully written"
9.4 Logging to a file
10 Data structures
GHC comes with some handy data-structures by default. If you want to use a Map, use Data.Map. For sets, you can use Data.Set. A good way to find efficient data-structures is to take a look at the hierarchical libraries, see Haskell Hierarchical Libraries and scroll down to 'Data'.
Arrays are generally eschewed in Haskell. However, they are useful if you desperately need constant lookup or update or if you have huge amounts of raw data.Immutable arrays like
bucketByResidual :: Int -> [Int] -> Array Int [Int] bucketByResidual n xs = accumArray (\xs x -> x:xs)  (0,n-1) [(x `mod` n, x) | x <- xs] Data.Arra.IArray> bucketByResidual 4 [x*x | x <- [1..10]] array (0,3) [(0,[100,64,36,16,4]),(1,[81,49,25,9,1]),(2,),(3,)] Data.Arra.IArray> amap reverse it array (0,3) [(0,[4,16,36,64,100]),(1,[1,9,25,49,81]),(2,),(3,)]
Note that the array can fill itself up in a circular fashion. Useful for dynamic programming. Here is the edit distance between two strings without array updates.
editDistance :: Eq a => [a] -> [a] -> Int editDistance xs ys = table ! (m,n) where (m,n) = (length xs, length ys) x = array (1,m) (zip [1..] xs) y = array (1,n) (zip [1..] ys) table :: Array (Int,Int) Int table = array bnds [(ij, dist ij) | ij <- range bnds] bnds = ((0,0),(m,n)) dist (0,j) = j dist (i,0) = i dist (i,j) = minimum [table ! (i-1,j) + 1, table ! (i,j-1) + 1, if x ! i == y ! j then table ! (i-1,j-1) else table ! (i-1,j-1)]
Mutable arrays like
import Control.Monad.State type Node = Int data Color = White | Grey | Black hasCycle :: Array Node [Node] -> Bool hasCycle graph = runState (mapDfs $ indices g) initSeen where initSeen :: DiffArray Node Color initSeen = listArray (bounds graph) (repeat White) mapDfs = fmap or . mapM dfs dfs node = get >>= \seen -> case (seen ! node) of Black -> return False Grey -> return True -- we found a cycle White -> do modify $ \seen -> seen // [(node,Grey )] found <- mapDfs (graph ! node) modify $ \seen -> seen // [(node,Black)] return found
11 Network programming
The following example makes use of the Network and System.IO libraries to open a socket connection to Google and retrieve the Google home page.
import Network; import System.IO; main = withSocketsDo $ do h <- connectTo "www.google.com" (PortNumber 80) hSetBuffering h LineBuffering hPutStr h "GET / HTTP/1.1\nhost: www.google.com\n\n" contents <- hGetContents h putStrLn contents hClose h