Cookbook

• Strings
• Numbers
• Dates and time
• Lists
• Other data structures
• Pattern matching
• Interactivity

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

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