Cookbook
This article is a draft, with further revisions actively invited. Drafts are typically different than stubs in that these articles are in an active edit process. Feel free to help by expanding the article.
We need to start a Haskell centered cookbook (aka, not a PLEAC clone)
This page is based on the Scheme Cookbook at http://schemecookbook.org/Cookbook/WebHome
Prelude
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.
GHCi/Hugs
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
`let' is also the way to create simple functions at the GHCi prompt
Prelude> let fact n = product [1..n]
Prelude> fact 5
120
Checking Types
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
Pattern matching
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.
Interactivity
Reading a string
Strings can be read as input using getLine.
Prelude> getLine
Foo bar baz
"Foo bar baz"
Printing a string
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"
Parsing command line arguments
TODO
Files
Reading from a file
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
Writing to a file
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"
This will override the old contents of the file, or create a new file if the file doesn't exist yet. If you want to append to a file, you can use appendFile
.
Creating a temporary file
TODO
Writing a filter
Using interact, you can easily do things with stdin and stdout.
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]
Logging to a file
TODO
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
XML
Libraries
There are multiple libraries available. In my own (limited) experience, I could only get HXT to do everything I wanted. It does make heavy use of [Arrows].
Parsing XML
TODO
Databases access
There are two packages you can use to connect to MySQL, PostgreSQL, Sqlite3 and ODBC databases: HDBC and Hsql
MySQL
TODO
PostgreSQL
TODO
SQLite
Suppose you have created a 'test.db' database like this,
$ sqlite3 test.db "create table t1 (t1key INTEGER PRIMARY KEY,data TEXT,num double,timeEnter DATE);"
$ sqlite3 test.db "insert into t1 (data,num) values ('This is sample data',3);"
$ sqlite3 test.db "insert into t1 (data,num) values ('More sample data',6);"
$ sqlite3 test.db "insert into t1 (data,num) values ('And a little more',9);"
Using HDBC and HDBC-sqlite3 packages, you can connect and query it like this:
import Control.Monad
import Database.HDBC
import Database.HDBC.Sqlite3
main = do conn <- connectSqlite3 "test.db"
rows <- quickQuery' conn "SELECT * from t1" []
forM_ rows $ \row -> putStrLn $ show row
$ ghc --make sqlite.hs
$ ./sqlite
output:
[SqlString "1",SqlString "This is sample data",SqlString "3.0",SqlNull]
[SqlString "2",SqlString "More sample data",SqlString "6.0",SqlNull]
[SqlString "3",SqlString "And a little more",SqlString "9.0",SqlNull]
Graphical user interfaces
wxHaskell
wxHaskell is a portable and native GUI library for Haskell based on the wxWidgets Library.
Hello World example:
module Main where
import Graphics.UI.WX
main :: IO ()
main
= start hello
hello :: IO ()
hello
= do f <- frame [text := "Hello!"]
quit <- button f [text := "Quit", on command := close f]
set f [layout := widget quit]
This code was taken from "a quick start with wxHaskell".
Gtk2Hs
Gtk2Hs is a GUI Library for Haskell based on GTK. Gtk2Hs Tutorial.
Hello world example:
import Graphics.UI.Gtk
main :: IO ()
main = do
initGUI
w <- windowNew
b <- buttonNew
set b [buttonLabel := "Quit"]
onClicked b $ widgetDestroy w
set w [windowTitle := "Hello", containerBorderWidth := 10]
containerAdd w b
onDestroy w mainQuit
widgetShowAll w
mainGUI
For more examples, see: Applications and libraries/Games
HOpenGL
HOpenGL is a Haskell binding for the OpenGL graphics API (GL 1.2.1 / GLU 1.3) and the portable OpenGL utility toolkit GLUT. There is a Haskell OpenGL Tetris program at [[1]] by Jim.
See also: Applications and libraries/Games
SDL
There are some Haskell bindings to SDL at Hackage.
PDF files
For the following recipes you need to install HPDF.
Creating an empty PDF file
The following code creates an empty PDF file with the name "test1.pdf":
import Graphics.PDF
main :: IO ()
main = do
let outputFileName= "test1.pdf"
let defaultPageSize = PDFRect 0 0 200 300
runPdf outputFileName standardDocInfo defaultPageSize $ do
addPage Nothing
Pages with different sizes
If you pass "Nothing" to the function addPage, the default page size will be used for the size of the new page.
Let’s create three pages, the last two pages with different dimensions:
import Graphics.PDF
main :: IO ()
main = do
let outputFileName= "test2.pdf"
let defaultPageSize = PDFRect 0 0 200 300
runPdf outputFileName standardDocInfo defaultPageSize $ do
addPage Nothing
addPage $ Just $ PDFRect 0 0 100 100
addPage $ Just $ PDFRect 0 0 150 150
FFI
How to interface with C
Magnus has written a nice example on how to call a C function operating on a user defined type.
Testing
QuickCheck
TODO
HUnit
TODO