Personal tools


From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(Added some more information on lists.)
(Added a Prelude)

Revision as of 18:33, 25 February 2007

We need to start a GOOD (aka, not a PLEAC clone) Haskell cookbook.

This page is based on the Scheme Cookbook at


1 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.

2 GHCi/Hugs

2.1 GHCi interaction

To start GHCi from a command prompt, simply type `ghci'

   $ ghci
      ___         ___ _
     / _ \ /\  /\/ __(_)
    / /_\// /_/ / /  | |      GHC Interactive, version 6.6, for Haskell 98.
   / /_\\/ __  / /___| |
   \____/\/ /_/\____/|_|      Type :? for help.
   Loading package base ... linking ... done.

Prelude is the "base" library of Haskell.

To create variables at the GHCi prompt, use `let'

Prelude> let x = 5
Prelude> x
Prelude> let y = 3
Prelude> y
Prelude> x + y

3 Types

To check the type of an expression or function, use the command `:t'

Prelude> :t x
x :: Integer
Prelude> :t y
y :: Integer

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      -- strings
    ()          -- the unit type
    Bool        -- booleans
    [a]         -- lists
    (a,b)       -- tuples / product types
    Either a b  -- sum types
    Maybe a     -- optional values

4 Strings

4.1 Input

Strings can be read as input using getLine.

Prelude> getLine
Foo bar baz
"Foo bar baz"

4.2 Output

Strings can be output in a number of different ways.

Prelude> putStr "Foo"

As you can see, putStr does not include the newline character `\n'. We can either use putStr like this:

Prelude> putStr "Foo\n"

Or use putStrLn, which is already in the Standard Prelude

Prelude> putStrLn "Foo"

We can also use print to print a string, including the quotation marks.

Prelude> print "Foo"

4.3 Concatenation

Concatenation of strings is done with the `++' operator.

Prelude> "foo" ++ "bar"

5 Numbers

Numbers in Haskell can be of the type
Int, Integer, Float, Double, or Rational

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

7 Lists

In 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]
Prelude> tail [1,2,3]
Prelude> length [1,2,3]

Furthermore, Haskell supports some neat concepts.

7.1 Infinite lists

Prelude> [1..]

The list of all squares:

square x = x*x
squares = map square [1..]
But in the end, you probably don't want to use infinite lists, but make them finite. You can do this with
Prelude> take 10 squares
===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)
In this function,
fact :: Integer -> Integer
is the functions type definition. The next line,
fact 0 = 1
is a pattern match, so when the argument to the function fact is 0, the return value is 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
fact 0 = 1
is evaluated before
fact n = n * fact (n - 1)

9 Arrays

10 Files

10.1 Simple IO

interact :: (String -> String) -> IO ()
, 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]

10.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

10.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"

10.4 Creating new files

11 Network Programming

12 XML

12.1 Parsing XML

13 Databases

13.1 MySQL

13.2 PostgreSQL

13.3 SQLite

14 FFI

14.1 How to interface with C