A Taste of Function Programming Using Haskell

DRAFT D. Vermeir

August 29, 2007

1 / 60

Introduction

1 2

Introduction Expressions, Values, Types User Dened Types Built-in types Functions Dening Functions Laziness and Innite Data Structures Case Expressions and Pattern Matching Type Classes and Overloading Monads Debuggable Functions Stateful Functions Monads Maybe Monad The IO Monad Epilogue
2 / 60

4 5

Introduction

What is Haskell?
Haskell is a lazy pure functional programming language. functional because the evaluation of a program is equivalent to evaluating a function in the pure mathematical sense; also there are no variables, objects, .. Other functional languagues include Lisp, Scheme, Erlang, Clean, ML, OCaml, . . . pure because it does not allow side effects (that affect the state of the world). One benet is referential transparency. This makes Haskell also a declarative language. lazy (aka non-strict) because expressions that are not needed for the result are not evaluated. This allows e.g. to support innite datastructures.
3 / 60

Expressions, Values, Types

1 2

Introduction Expressions, Values, Types User Dened Types Built-in types Functions Dening Functions Laziness and Innite Data Structures Case Expressions and Pattern Matching Type Classes and Overloading Monads Debuggable Functions Stateful Functions Monads Maybe Monad The IO Monad Epilogue
4 / 60

4 5

Expressions, Values, Types

Precedence
f g 5

= ((f g) 5)

function application (f g) has higher precedence than any inx operator

f 1 + g 3 -- (f 1) + (g 3)

Inx operators can be (left/right/non) associative and have a precedence between 0 (low) and 9 (high).
prec 9 8 7 6 5 4 3 2 1 0 left !! *, /, div, rem, quot +, mod, non . ^, ^^, ** right

:, ++ ==, /=, <, <=, >, >=, elem, notElem && || >>=, >> $, $!, seq

5 / 60

Expressions, Values, Types

Expressions and Values

Computation is done via the evaluation of expressions (syntactic terms) yielding values (abstract entities, answers). All values are rst class. denotes expression
5 a [1,2,3] (b, 4) \x -> x+1

e.g. 1/0

value 5 a the list 1, 2, 3 the pair b , 4 the function x x + 1

6 / 60

Expressions, Values, Types

Values and Types

Every value has an associated type. Types are denoted by type expressions. Intuitively, a type describes a set of values. Haskell is statically typed: the compiler will catch type errors. expression
5 a [1,2,3] (b, 4) \x -> x+1

value 5 a the list 1, 2, 3 the pair b , 4 the function x x + 1

type (expression)
Integer Char [Integer] (Char,Integer) Integer -> Integer

7 / 60

Expressions, Values, Types

Declarations

inc :: Integer -> Integer -- a type declaration inc n = n + 1 -- a function equation

8 / 60

Expressions, Values, Types

Polymorphic Types
Polymorphic type expressions are universally quantied over types. They describe families of types. [] describes all types of the form list of for some type .
length

computes the length of any (homogeneous) list.

length :: [a] -> Integer length [] = 0 -- pattern matching on argument length (x:xs) = 1 + length xs -- : is cons

Example usage:
length [1,2,3] -- 3 length [a,b,c] -- 3 length [[1],[2],[3]] -- 3

9 / 60

Expressions, Values, Types

More Polymorphic List Functions

head :: [a] -> a head (x:xs) = x -- error if no match, e.g. for empty list tail :: [a] -> [a] tail (x:xs) = xs

10 / 60

Expressions, Values, Types

Type Hierarchy

A value may have several types, e.g. [a,b]::[Char] and [a,b]::[a]. Every well-typed expression is guaranteed to have a unique principal type, i.e. the least general type that, intuitively, contains all instances of the expression. For example, the principal type of head is [a]->a, although e.g. a and [b]->a are also types for head. The principal type of a well-typed expression can be inferred automatically. is shared by all types

11 / 60

Expressions, Values, Types

User Dened Types

User Dened Types

data Bool = False | True

The type Bool has exactly two values: True and False. Type Bool is an example of a (nullary) type constructor, and True and False are (also nullary) (data) constructors.
-- another sum (disjoint union) type data Color = Red | Green | Blue | Indigo | Violet

12 / 60

Expressions, Values, Types

User Dened Types

User Dened Polymorphic Types

A tuple (Cartesian product) type with just one binary (data) constructor with type Pt:: a -> a -> Point a.
data Point a = Pt a a

Note that Point is also polymorphic: Point t is a type for any type
t. Pt Pt Pt -2.0 3.0 :: Point Float a b :: Point Char True False :: Point Bool Pt 1 a is ill-typed

Since the namespaces for type constructors (Point) and data constructors (Pt) are separate, one can use the same name for both.
data Point a = Point a a

13 / 60

Expressions, Values, Types

User Dened Types

User Dened Recursive Types

A tree is either a leaf (with a label of type a) or an internal node with two subtrees.
data Tree a = Leaf a | Branch (Tree a) (Tree a)

The types of the (data) constructors:

Branch :: Tree a -> Tree a -> Tree a Leaf :: a -> Tree a

A function to compute the list of leaf contents:

fringe :: Tree a -> [a] fringe (Leaf x) = [x] fringe (Branch left right) = fringe left ++ fringe right -- ++ is list concatenation

14 / 60

Expressions, Values, Types

User Dened Types

Type Synonyms

A type synonym denes an abbreviation for a type.

type type type data String = [Char] Person = (Name,Address) Name = String Address = None | Addr String

type AssocList a b = [(a,b)]

15 / 60

Expressions, Values, Types

Built-in types

Built-in types are not special

(Apart from the syntax). Examples: lists:
data [a] = [] | a : [a]

which yields the following types for the list constructors:

[] :: [a] : :: a->[a]->[a].

characters:
data Char = a | b | c | ... -- This is not valid | A | B | C | ... -- Haskell code! | 1 | 2 | 3 | ... ...

16 / 60

Expressions, Values, Types

Built-in types

List Comprehension

The list of all f (x) such that x comes from xs:

[ f x | x <- xs ] -- x <- xs is the generator [ (x,y) | x <- xs, y <- ys ] -- 2 generators [ (x,y) | x <- [1,2], y <- [3,4] ] -- [(1,3),(1,4),(2,3),(2,4)]

Extra conditions (guards) are also possible:

quicksort [] = [] quicksort (x:xs) = quicksort [y | y <- xs, y<x ] ++ [x] ++ quicksort [y | y <- xs, y>=x]

17 / 60

Functions

1 2

Introduction Expressions, Values, Types User Dened Types Built-in types Functions Dening Functions Laziness and Innite Data Structures Case Expressions and Pattern Matching Type Classes and Overloading Monads Debuggable Functions Stateful Functions Monads Maybe Monad The IO Monad Epilogue
18 / 60

4 5

Functions

Dening Functions

User Dened Functions

Use currying (i.e. consider a function f : A B C as a function f : A (B C) where f (a, b) = f (a)(b)):
add :: Integer -> Integer -> Integer add x y = x + y

Because of currying, partial application is supported:

inc = add 1 -- or (+1)

Example:
map :: (a->b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x : map f xs -- precedence: (f x) : (map f xs) map (add 1) [1,2,3] -[2,3,4]

19 / 60

Functions

Dening Functions

Anonymous Functions

Using lambda expressions:

inc x = x+1 add x y = x+y

is really shorthand for

inc = \x -> x+1 add = \x -> \y -> x+y -- or \x y -> x+y

20 / 60

Functions

Dening Functions

Inx Operators are Functions

Function composition (.)
(.) :: (b->c) -> (a->b) -> (a->c) f . g = \ x -> f (g x) -- high precedence f . h . g 1 -- f (h.g 1) = (f (h ( g 1))) -- but function application ( ) has higher precedence -- than any infix operator bind f . h x -- (bind f) ( h ( x) )

Function application ($)

($) :: (a->b) -> a -> b f $ x = f x -- low precedence f h $ g 1 -- (f h) (g 1), not (((f h) g) 1)

21 / 60

Functions

Laziness and Innite Data Structures

Functions are Non-Strict

bot = bot -- denotes const1 x = 1 const1 bot -- value is 1, not

Lazy Evaluation
An expression is not evaluated until it is needed (and then only the parts that are needed are evaluated).

Haskell Stores Denitions, not Values

v = 1/0 -- define (not compute) v as 1/0

22 / 60

Functions

Laziness and Innite Data Structures

Innite Data Structures

ones = 1 : ones -- an infinite list of 1s numsFrom n = n : numsFrom (n+1) -- n, n+1, ... squares = map (^2) (numsFrom 0) -- 0, 1, 4, 9, ...

Zip
zip (x:xs) (y:ys) = (x,y) : zip xs ys zip xs ys = []

Fibonacci Sequence
fib = 1 : 1 : [ a + b | (a,b) <- zip fib (tail fib) ] -- fib = 1 1 2 3 5 8 ..

23 / 60

Functions

Case Expressions and Pattern Matching

Pattern Matching
Using constructors of any type, formal parameters or wild cards.
f :: ([a], Char, (Int, Float), String, Bool) -> Bool f ([], b, (1,2.0), "hi", _) = False -- last one is wild card f (_, _, (2,4.0), "", True) = True f (x, _, (2,4.0), "", y) = length x > 0 || y -- formal pars -- only 1 occurrence of same formal parameter in pattern

Semantics
if match succeeds: bind formal parameter fails: try next pattern diverges: (): return

24 / 60

Functions

Case Expressions and Pattern Matching

Pattern Matching with Guards

-- Guards are tested -- Only one matching sign 0 | True = 0 -sign x | x > 0 = 1 | x < 0 = -1 | otherwise = after the corresponding pattern pattern is tried contrived, dont move to the end

-1 -- otherwise is True

Common Where Clause

isBright c | | | | where r == 255 = True g == 255 = True b == 255 = True otherwise = False (r,g,b) = color2rgb c

25 / 60

Functions

Case Expressions and Pattern Matching

take1, take2
take1 0 _ = [] take1 _ [] = [] take1 n (x:xs) = x : take1 (n-1) xs take2 _ [] = [] take2 0 _ = [] take2 n (x:xs) = x : take2 (n-1) xs

different results
take1 take2 take1 take2 0 bot -- [] 0 bot -- bot [] -- bot [] -- []

26 / 60

Functions

Case Expressions and Pattern Matching

Syntax Case Expressions

case (e1 , .. , en ) of (p1,1 , .. , p1,n ) -> r1 (p2,1 , .. , p2,n ) -> r2 ... (pm,1 , .. , pm,n ) -> rm

where pi,j are patterns.

if .. then .. else
if (e1 ) then e2 else e3

is short for
case (e1 ) of True -> e2 False -> e3

27 / 60

Functions

Case Expressions and Pattern Matching

Pattern Matching is a Case Expression

f p1,1 , .. , p1,n = e1 f p2,1 , .. , p2,n = e2 ... f pm,1 , .. , pm,n = em

is equivalent to
f x1 x2 .. xn = case (x1 x2 .. (p1,1 , .. , p1,n ) -> e1 (p2,1 , .. , p2,n ) -> e2 ... (pm,1 , .. , pm,n ) -> em xn ) of

28 / 60

Type Classes and Overloading

1 2

Introduction Expressions, Values, Types User Dened Types Built-in types Functions Dening Functions Laziness and Innite Data Structures Case Expressions and Pattern Matching Type Classes and Overloading Monads Debuggable Functions Stateful Functions Monads Maybe Monad The IO Monad Epilogue
29 / 60

4 5

Type Classes and Overloading

Restricted Polymorphism

List Membership
-- x elem list iff x appears in list x elem [] = False x elem (y:ys) = x == y || ( x elem ys)

Type of elem
One would expect: elem:: a -> [a] -> Bool but this would imply (==):: a -> a -> Bool but == may not be dened on some types! Thus elem:: a -> [a] -> Bool only for a where (==):: a -> a -> Bool is dened.

30 / 60

Type Classes and Overloading

Type Classes
Class Eq
-- A type a is an instance of the class Eq iff -- there is an appropriate overloaded operation == defined on it class Eq a where (==) :: a -> a -> Bool

Context with Type Expressions

-- (Eq a) is the context (==) :: (Eq a) => a -> a -> Bool elem :: (Eq a) => a -> [a] -> Bool

31 / 60

Type Classes and Overloading

Instances of Type Classes

class Eq a where (==), (/=) :: a -> a -> Bool x /= y = not (x==y) -- default method

Integer is an instance of Eq
instance Eq Integer where x == y = x integerEq y -- integerEq is primitive

Tree may be an instance of Eq

instance (Eq a) => Eq (Tree a) where -- context! Leaf a == Leaf b = a == b (Branch l1 r1) == (Branch l2 r2) = (l1 == l2 ) && (r1 == r2) _ == _ = False

32 / 60

Type Classes and Overloading

Class Extension or (Multiple) Inheritance

Ord is a Subclass of Eq
class (Eq a) => Ord a where (<), (<=), (>=), (>) :: a -> a -> Bool max, min :: a -> a -> a -- example: type of quicksort quicksort :: (Ord a) => [a] -> [a]

C is a Subclass of Ord and Show

class (Eq a, Show a) => C a where ...

33 / 60

Monads

1 2

Introduction Expressions, Values, Types User Dened Types Built-in types Functions Dening Functions Laziness and Innite Data Structures Case Expressions and Pattern Matching Type Classes and Overloading Monads Debuggable Functions Stateful Functions Monads Maybe Monad The IO Monad Epilogue
34 / 60

4 5

Monads

Debuggable Functions

Example Problem
f,g :: Int -> Int

Adding debug info

-- debuggable versions of f, g f,g :: Int -> (Int,String)

Debug info for f.g

"g." x g f "f."

++

"g.f."

35 / 60

Monads

Debuggable Functions

A Complex Solution
s++t

s y

t z

++

Debug info for f.g

f,g :: Int -> (Int,String) gThenF :: Int -> (Int,String) gThen F x = let (y,s) = g x (z,t) = f y in (z,s++t)

This quickly becomes complicated (e.g. with 3 functions)!

36 / 60

Monads

Debuggable Functions

Introducing bind
Debug info for f.g
f,g :: Int -> (Int,String)

We would like a function bind such that bind f . g is debuggable.

bind

requirements
must accept output from g as input

bind f

bind f :: (Int,String) -> (Int,String)

and thus
bind :: ((Int -> (Int,String)) -> (Int,String) -> (Int,String)

37 / 60

Monads

Debuggable Functions

Solution using bind

bind f s y t z ++ s++t

bind :: ((Int -> (Int,String)) -> (Int,String) -> (Int,String) bind f (gx,gs) = let (fx,fs) = f gx in (fx,gs++fs)

For 3 functions: bind h . bind f . g etc. We write g >>= f (low precedence) for bind f . g.

38 / 60

Monads

Debuggable Functions

Combining normal functions with debuggable ones

We want a function unit such that unit . h becomes debuggable for any normal h :: Int -> Int.

Requirements for unit

h :: Int -> Int unit . h :: Int -> (Int, String) -- and thus unit :: Int -> (Int, String)

Solution for unit

unit :: Int -> (Int, String) unit x = (x, "") lift :: (Int -> Int) -> Int -> (Int,String) lift f = unit . f
39 / 60

Monads

Debuggable Functions

Theorem
unit >>= f

= f

Proof.
unit >>= f = bind f .unit = x bind f (unit x) = x bind f (x, ) = x ((u, v ) let (y , s) = f u in (y , v ++s))(x, ) = x ( let (y , s) = f x in (y , ++s)) = x ( let (y , s) = f x in (y , s)) = x f x = f

40 / 60

Monads

Debuggable Functions

Theorem
(f >>= unit)

= f

Proof.
f >>= unit = bind unit .f = x bind unit (f x) = x ((u, v ) let (y , s) = unit u in (y , v ++s))(f x) = x ((u, v ) let (y , s) = (u, ) in (y , v ++s))(f x) = x ((u, v ) (u, v ++))(f x) = x ((u, v ) (u, v ))(f x) = x f x = f

41 / 60

Monads

Debuggable Functions

Theorem
(lift g >>= lift f)

= lift (f.g)

Proof.
lift g >>= lift f = bind (lift f ).lift g = x bind (lift f )(lift g x) = x bind (unit.f )(unit.g x) = x bind (unit.f )(gx, ) = x ((u, v ) let (y , s) = unit.f u in (y , v ++s))(gx, ) = x let (y , s) = unit.f (gx) in (y , ++s) = x let (y , s) = (f (gx), ) in (y , s) = x (f .g x, ) = x unit.(f .g) x = unit.(f .g) = lift f .g
42 / 60

Monads

Stateful Functions

Stateful Functions

A function g: a -> b that uses and updates a state has type.

g :: a -> s -> (b,s) -- g(input, oldState) = (output, newState)

Another way of looking at such functions hides the part involving the state(s).

Hiding the state part

g :: a -> s -> (b, s) g(input) :: oldState -> (output, newState)

43 / 60

Monads

Stateful Functions

Combining Stateful Functions

How to run two such functions f and g, where f consumes the result of g and uses the state as it was left by g.

gThenF (g;f in C)
g :: a -> s -> (b, s) f :: b -> s -> (c, s) gThenF :: (a -> s -> (b,s)) -> (b -> s -> (c,s)) -> a -> s -> (c, s) gThenF g f a = \s -> let (gOut, s) = g a s in f gOut s

Becomes complicated when composing many such functions.

44 / 60

Monads

Stateful Functions

Combining Stateful Functions using Bind

bind

requirements

bind f . g
a s
bind bind -- g bind -- f bind

b s

c s

f . g a :: s -> (s, c) f . g :: a -> s -> (s,c) :: a -> ( s -> (b,s) ) f :: (s -> (b,s)) -> s -> (s,c) :: b -> ( s -> (c,s) ) :: (b -> ( s -> (c,s) )) -> ((s -> (b,s)) -> s -> (s,c))

45 / 60

Monads

Stateful Functions

Bind Implementation

bind f . g
a s

b s

c s

bind :: (b -> ( s -> (c,s) )) -> ((s -> (b,s)) -> s -> (s,c)) bind f ga = \s -> let (b, s) = ga s in f b s

46 / 60

Monads

Stateful Functions

bind :: (b -> ( s -> (c,s) )) -> ((s -> (b,s)) -> s -> (s,c)) bind f ga = \s -> let (b, s) = ga s in f b s

it works
bind f . g a = bind f ( g a) = \s -> let (b, s) = (g a) s in f b s

example
h :: c -> s -> (d,s) bind h . bind f . g a :: s -> (d,s) -- we write g >>= f for bind f . g (g >>= f >>= h) a s

47 / 60

Monads

Stateful Functions

Combining normal functions with stateful ones

We want a function unit such that e.g. unit . h becomes stateful for any normal h :: a -> a.

Requirements for unit

h :: a -> a unit . h :: a -> s -> (a, s) -- and thus unit :: a -> s -> (a, s)

Solution for unit

unit :: a -> s -> (a, s) unit xa = \s -> (xa, s) lift :: (a -> a) -> a -> s -> (a,s) lift h = unit . h
48 / 60

Monads

Stateful Functions

Example Use of Unit

unit.h a s

b s

b s

c s

g :: a -> s -> (b,s) h :: b -> b f :: b -> s -> (c,s) -- lift h :: b -> s -> (b,s) (g >> lift h >> f) a s

49 / 60

Monads

Monads

Generalizing the examples

type Debuggable a = (a, String) type State a = s -> (a, s) -- assume s is known type M a = .. -- in general

How to apply a function f:: a -> M b to a value of type M a?

Answer: Bind, Unit

bind :: (a -> M b) -> (M a -> M b) f :: a -> M b g :: a -> M a -- apply f to (result of) g bind f . g :: a -> M b unit :: a -> M a

where bind g .unit bind unit.g g

50 / 60

Monads

Monads

Monads
data M a = .. -- in general bind :: (a -> M b) -> (M a -> M b) unit :: a -> M a infixl 1 >>= -- infix, right-associative, prec. 1 (low) (>>=) :: M a -> (a -> M b) -> M b ma >>= f = bind f ma -- in our examples return :: a -> M a return = unit -- in our examples

where
return a >>= f ma >>= return ma >>= (\x -> f x >>= h)

= = =

f a ma (ma >>= f) >>= h

51 / 60

Monads

Monads

The Monad Class

infixl 1 >>=, >> class Monad M where -- approximation of real definition (>>=) :: M a -> (a -> M b) -> M b (>>) :: M a -> M b -> M b return :: a -> M a -- inject a value into the monad ma >> mb = ma >>= \_ -> mb -- ignore (result of) ma

Special Monad Syntax (Informal)

do e1; e2 do p <- e1; e2

= =

e1 >> e2 e1 >>= \p -> e2

imperative style e2 probably uses p

52 / 60

Monads

Maybe Monad

The Maybe type

A Maybe value represents a real value (Just a) or no value (Nothing).
data Maybe a = Nothing | Just a

Code to avoid
e :: Maybe a f :: a -> Maybe a case e of Nothing -> Nothing Just x -> f x

53 / 60

Monads

Maybe Monad

Maybe Monad
instance Monad Maybe where Nothing >>= f = Nothing (Just x) >>= f = f x return = Just

Code to avoid
e :: Maybe a f :: a -> Maybe a case e of Nothing -> Nothing Just x -> f y

.. becomes
e >>= f -- will not call f unless ..
54 / 60

Monads

The IO Monad

I/O conicts with lazy evaluation

Side effects (e.g. I/O) update the state of the world, we want to ensure the order of the I/O operations.

The IO Monad is much like the State Monad

type IO a = World -> (World, a)

IO a
A value x:: IO a represents an action that, when performed, does some I/O before delivering a value of type a
a

IO a
World World

55 / 60

Monads

The IO Monad

getChar, putChar
Read/write a single character.
getChar :: IO Char putChar :: Char -> IO () -- returns trivial value ()

IO bind
(>>=) :: IO a -> ( a -> IO b) -> IO b echo :: IO() echo = getChar >>= putChar -- a = Char, b = ()
Char World getChar::IO Char World putChar::IO () () World

echo :: IO ()

56 / 60

Monads

The IO Monad

echo; echo
(>>=) :: IO a -> ( a -> IO b) -> IO b -- echo :: IO () echo >>= echo -- ERROR: 2nd echo should be function () -> IO ()

(>>) :: IO a -> IO b -> IO b -- throw away result first argument (>>) a1 a2 = a1 >>= (\x -> a2) echo >> echo -- OK, read >> as then

return
return :: a -> IO a

a World

return a (return

World

a):: IO a
57 / 60

Monads

The IO Monad

get2Chars
get2Chars :: IO (Char, Char) get2Chars = getChar >>= \c1 -> (getChar >>= (\c2 -> return (c1,c2)))

The world behaves as expected

Since >>= is the only function touching the world, the world is never duplicated or thrown away and getChar and putChar can be implemented by performing the operation right away.

58 / 60

Epilogue

1 2

Introduction Expressions, Values, Types User Dened Types Built-in types Functions Dening Functions Laziness and Innite Data Structures Case Expressions and Pattern Matching Type Classes and Overloading Monads Debuggable Functions Stateful Functions Monads Maybe Monad The IO Monad Epilogue
59 / 60

4 5

Epilogue

Not Covered
modules, named elds, arrays, nite maps, strict elds, kinds, comonads, arrows, monad transformers, parsing monads, type theory ...

References
See website. Most of the material on these slides comes from A Gentle Introduction to Haskell 98 by Hudak et al. The Monad introduction is based on http://sigfpe.blogspot.com/2006/08/ you-could-have-invented-monads-and.html S. Peyton Jones, Tackling the Awkward Squad: monadic I/O, concurrency, exception and foreign-language calls in Haskell, 2005.

Acknowledgements
Dries Harnie pointed out errors in earlier versions.
60 / 60