An Introduction to Functional Programming using Haskell

An Introduction to
Functional Programming
using Haskell
Michel Rijnders <mies@tty.nl>

Administrativia
Anglais?
tuple programming
skill level
working ghci
handouts
breaks

Main Features
purely functional
lazy
higher order
strongly typed
general purpose

History

September 1987 FPCA
“design by committee”
P. Hudak, J. Hughes, S. Peyton Jones, and
P. Wadler: “A History of Haskell: Being
Lazy With Class” (2007)

Main Difference

mainstream languages are all about
state
functional programming is all about
values

Computation

all computation is done via the
evaluation of EXPRESSIONS to yield
VALUES
every value has an associated TYPE

Types

basic types: Char, Bool, Int, Integer,
Double
composite types
lists: [Char], [Int], [[Char]]
tuples: (String,Int)

Function Types

square :: Integer -> Integer
(&&) :: Bool -> Bool -> Bool
length :: [a] -> Int
(:) :: a -> [a] -> [a]

Function Deﬁnitions
fac :: Int -> Int
fac n = if n == 0
then 1
else n * fac (n - 1)

Guards
-- guards
fac’ :: Int -> Int
fac’ n
| n == 0 = 1
| otherwise = n * fac’ (n - 1)

Pattern Matching
-- pattern matching
fac’’ :: Int -> Int
fac’’ 0 = 1
fac’’ n = n * fac’’ (n - 1)

Exercises Template
-- file: Main.hs
module Main where

import Prelude hiding (sum,length)

sum :: [Int] -> Int
...

length :: [a] -> Int
...

List Patterns
[]
xs
(x:xs)
(x:_)
(_:xs)
(_:_)

Summary
computation
types
functions
guards
pattern matching
list comprehensions

Coming Up

programming with lists
higher-order functions
type classes
algebraic types

List Functions
(:) :: a -> [a] -> [a] tail, init :: [a] -> [a]

(++) :: [a] -> [a] -> [a] replicate ::
Int -> a -> [a]
(!!) :: [a] -> Int -> [a]
take, drop ::
concat :: [[a]] -> [a] Int -> [a] -> [a]

length :: [a] -> Int splitAt ::
Int -> [a] -> ([a],[a])
head, last :: [a] -> a

More List Functions
repeat :: a -> [a] and, or ::
[Bool] -> Bool
reverse :: [a] -> [a]
sum, product ::
zip :: [Int] -> Int
[a] -> [b] -> [(a,b)] [Float] -> Float

unzip ::
[(a,b)] -> ([a],[b])

Programming with Lists
Prelude> :load Sprite
*Sprite> print glider
.#.
..#
###
[(),(),()]
*Sprite> print (flipH glider)
###
..#
.#.
[(),(),()]

Sprite.hs
flipH :: Picture -> Picture
flipH pic = reverse pic

flipV :: Picture -> Picture
flipV pic =
[ reverse line | line <- pic ]

Higher Order Functions

functions as arguments
functions as results
or both

Higher Order Functions

patterns of computation
mapping: transforming elements
ﬁltering: selecting elements
folding: combining elements

Mapping and Filtering

map :: (a -> b) -> [a] -> [b]
ﬁlter :: (a -> Bool) -> [a] -> [a]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

Folding

foldl :: (a -> b -> a) -> a -> [b] -> a
foldl1 :: (a -> b -> a) -> [b] -> a
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr1 :: (a -> a -> a) -> [a] -> a

Type Classes

type class: a collection of of types over
which certain functions are deﬁned
equality class Eq
(==) :: (Eq a) => a -> a -> Bool
(/=) :: (Eq a) => a -> a -> Bool

Declaring a Class
class Visible a where
toString :: a -> String
size :: a -> Int

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

Deﬁning an Instance
instance Visible Char where
toString ch = [ch]
size _ = 1

instance Eq Bool where
True == True = True
False == False = True
_ == _ = False

Derived Classes
class Eq a => Ord a where
(<), (<=), (>), (>=) :: a -> Bool
max, min :: a -> a -> a
compare :: a -> a -> Ordering

Built-In Classes
Eq
Ord
Enum
Show
Read

Product Types
data People = Person Name Age
type Name = String
type Age = Int
data Shape = Circle Double
| Rectangle Float Float

Recursive Algebraic
Types
data Expr = Lit Int
| Add Expr Expr
| Sub Expr Expr
data Tree a = Node (Tree a) (Tree a)
| Leaf a

More?

http://haskell.org/
G. Hutton: Programming in Haskell
(Cambridge University Press)
B. O’Sullivan, J. Goerzen, D. Stewart:
Real World Haskell (O’Reilly)

An Introduction to Functional Programming using Haskell

More Related Content

What's hot (15)

Viewers also liked (20)

Similar to An Introduction to Functional Programming using Haskell (20)

Recently uploaded (20)

An Introduction to Functional Programming using Haskell

Editor's Notes