Lazy Functional Programming in Haskell
|
|
|
- Hilary Freeman
- 6 years ago
- Views:
Transcription
1 Lazy Functional Programming in Haskell David Raymond Christiansen 25 November, 2013
2 What is Haskell? 2
3 What is Haskell? Pure functional language: no side effects 2
4 What is Haskell? Pure functional language: no side effects Lazy evaluation: function arguments are evaluated when needed 2
5 What is Haskell? Pure functional language: no side effects Lazy evaluation: function arguments are evaluated when needed Rich type system: higher-order types 2
6 Just the latest hipster fad?
7 Why Should I Care? Get better at functional programming 4
8 Why Should I Care? Get better at functional programming Laboratory for new language features use the future, today! 4
9 Why Should I Care? Get better at functional programming Laboratory for new language features use the future, today! Very mature compiler and tools 4
10 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 5
11 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 6
12 Hello, world module Main main :: IO () main = do putstrln "Who are you?" name <- getline putstrln ("Hello, " ++ name) 6
13 Fibonacci fib :: Int -> Int fib 0 = 0 fib 1 = 1 fib n = fib (n - 1) + fib (n - 2) 7
14 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 8
15 Expressions Function application: f x y z 8
16 Expressions Function application: f x y z Anonymous functions: \x y -> x + y 8
17 Expressions Function application: f x y z Anonymous functions: \x y -> x + y Infix operators: f x + 3 8
18 Expressions Function application: f x y z Anonymous functions: \x y -> x + y Infix operators: f x + 3 Infix function application: 2 elem [1, 2, 3] 8
19 Expressions Function application: f x y z Anonymous functions: \x y -> x + y Infix operators: f x + 3 Infix function application: 2 elem [1, 2, 3] Prefix operator application: (+) 1 2 8
20 Expressions Function application: f x y z Anonymous functions: \x y -> x + y Infix operators: f x + 3 Infix function application: 2 elem [1, 2, 3] Prefix operator application: (+) 1 2 Operator slices: map (+ 1) [1, 2, 3] 8
21 Expressions Function application: f x y z Anonymous functions: \x y -> x + y Infix operators: f x + 3 Infix function application: 2 elem [1, 2, 3] Prefix operator application: (+) 1 2 Operator slices: map (+ 1) [1, 2, 3] Function composition: f. g = \x -> f (g x) 8
22 Function Definitions F#: let rec reverse (lst : a list) : a list = match lst with [] => [] (x::xs) => reverse [x] 9
23 Function Definitions F#: let rec reverse (lst : a list) : a list = match lst with [] => [] (x::xs) => reverse [x] Haskell: reverse :: [a] -> [a] reverse [] = [] reverse (x:xs) = reverse xs ++ [x] 9
24 Where blocks reverse :: [a] -> [a] reverse xs = helper [] xs where helper acc [] = acc helper acc (y:ys) = helper (y:acc) ys Put the interesting part first! 10
25 Data Definitions data Maybe a = Just a Nothing 11
26 Data Definitions data Maybe a = Just a Nothing data List a = Cons a (List a) Nil 11
27 Data Definitions data Maybe a = Just a Nothing data List a = Cons a (List a) Nil data Tree a = Empty Node (Tree a) a (Tree a) 11
28 Data Definitions data Maybe a = Just a Nothing data List a = Cons a (List a) Nil data Tree a = Empty Node (Tree a) a (Tree a) data Either a b = Left a Right b 11
29 Data Definitions data Maybe a = Just a Nothing data List a = Cons a (List a) Nil data Tree a = Empty Node (Tree a) a (Tree a) data Either a b = Left a Right b data Labeled a = Labeled String a 11
30 Case Sensitivity UPPERCASE Types Constructors Type constructors Modules 12
31 Case Sensitivity UPPERCASE Types Constructors Type constructors Modules LOWERCASE Variables Type variables Defined operators 12
32 Indentation Haskell is indentation-sensitive (like F#): reverse :: [a] -> [a] reverse xs = helper [] xs where helper acc [] = acc helper acc (y:ys) = helper (y:acc) ys won t compile. 13
33 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 14
34 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 14
35 Lazy Evaluation STRICT EVALUATION evaluates arguments before calling functions LAZY EVALUATION evaluates arguments as they are used 14
36 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] 15
37 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) 15
38 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) 15
39 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) 15
40 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] 15
41 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] 15
42 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) 15
43 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [2,3,4,5]))) 15
44 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [3,4,5]))) 15
45 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [3,4,5]))) ==> "4" : (map show (map (+1) (filter (>2) [4,5]))) 15
46 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [3,4,5]))) ==> "4" : (map show (map (+1) (filter (>2) [4,5]))) ==> "4" : "5" : (map show (map (+1) (filter (>2) [5]))) 15
47 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [3,4,5]))) ==> "4" : (map show (map (+1) (filter (>2) [4,5]))) ==> "4" : "5" : (map show (map (+1) (filter (>2) [5]))) ==> "4" : "5" : "6" : (map show (map (+1) (filter (>2) [])) 15
48 Strict vs Lazy Evaluation Strict: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) [3,4,5])) ==> (map show [4,5,6]) ==> ["4","5","6"] Lazy: (map show. map (+1). filter (>2)) [1,2,3,4,5] ==> (map show (map (+1) (filter (>2) [1,2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [2,3,4,5]))) ==> (map show (map (+1) (filter (>2) [3,4,5]))) ==> "4" : (map show (map (+1) (filter (>2) [4,5]))) ==> "4" : "5" : (map show (map (+1) (filter (>2) [5]))) ==> "4" : "5" : "6" : (map show (map (+1) (filter (>2) [])) ==> ["4","5","6"] 15
49 Infinite Data Structures zipwith :: (a -> b -> c) -> [a] -> [b] -> [c] 16
50 Infinite Data Structures zipwith :: (a -> b -> c) -> [a] -> [b] -> [c] zipwith f [] _ = [] zipwith f _ [] = [] zipwith f (x:xs) (y:ys) = f x y : zipwith f xs ys 16
51 Infinite Data Structures zipwith :: (a -> b -> c) -> [a] -> [b] -> [c] zipwith f [] _ = [] zipwith f _ [] = [] zipwith f (x:xs) (y:ys) = f x y : zipwith f xs ys fibs :: [Int] fibs = 0 : 1 : zipwith (+) fibs (tail fibs) 16
52 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) 17
53 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs 17
54 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK 17
55 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK ==> take 3 (0 : THUNK) 17
56 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK ==> take 3 (0 : THUNK) ==> 0 : (take 2 THUNK) 17
57 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK ==> take 3 (0 : THUNK) ==> 0 : (take 2 THUNK) ==> 0 : 1 : (take 1 THUNK) 17
58 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK ==> take 3 (0 : THUNK) ==> 0 : (take 2 THUNK) ==> 0 : 1 : (take 1 THUNK) ==> 0 : 1 : 1 : (take 0 THUNK) 17
59 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK ==> take 3 (0 : THUNK) ==> 0 : (take 2 THUNK) ==> 0 : 1 : (take 1 THUNK) ==> 0 : 1 : 1 : (take 0 THUNK) ==> 0 : 1 : 1 : [] 17
60 Infinite Data Structures fibs = 0 : 1 : zipwith (+) fibs (tail fibs) take 3 fibs ==> take 3 THUNK ==> take 3 (0 : THUNK) ==> 0 : (take 2 THUNK) ==> 0 : 1 : (take 1 THUNK) ==> 0 : 1 : 1 : (take 0 THUNK) ==> 0 : 1 : 1 : [] After execution, fibs = 0 : 1 : 1 : THUNK 17
61 The Hair Shirt Simon Peyton Jones: Laziness kept Haskell honest 1 Laziness makes side effects completely unpredictable 1 haskell-retrospective/haskellretrospective.pdf 18
62 The Hair Shirt Simon Peyton Jones: Laziness kept Haskell honest 1 Laziness makes side effects completely unpredictable Thus, Haskell is still pure 1 haskell-retrospective/haskellretrospective.pdf 18
63 Lazy Lists are Control Structures var output = "" for (i <- 1 to 10) { output = output + i.tostring } vs (concat. take 10. map show) [1..] 19
64 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 20
65 Dude - where s my RAM?
66 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs 21
67 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Summing a list: foldl (+) 0 [1..10] 21
68 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Summing a list: foldl (+) 0 [1..10] ==> foldl (+) (0 + 1) [2..10] 21
69 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Summing a list: foldl (+) 0 [1..10] ==> foldl (+) (0 + 1) [2..10] ==> foldl (+) ((0 + 1) + 2) [3..10] 21
70 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Summing a list: foldl (+) 0 [1..10] ==> foldl (+) (0 + 1) [2..10] ==> foldl (+) ((0 + 1) + 2) [3..10] ==> foldl (+) (((0 + 1) + 2) + 3) [4..10] 21
71 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Summing a list: foldl (+) 0 [1..10] ==> foldl (+) (0 + 1) [2..10] ==> foldl (+) ((0 + 1) + 2) [3..10] ==> foldl (+) (((0 + 1) + 2) + 3) [4..10]... ==> foldl (+) (((((0 + 1) + 2) + 3) + 4) ) [] 21
72 Space Leaks and Laziness Recall foldl: foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Summing a list: foldl (+) 0 [1..10] ==> foldl (+) (0 + 1) [2..10] ==> foldl (+) ((0 + 1) + 2) [3..10] ==> foldl (+) (((0 + 1) + 2) + 3) [4..10]... ==> foldl (+) (((((0 + 1) + 2) + 3) + 4) ) [] Code to perform repeated additions takes much more space than the answer 21
73 Tools Strictness annotations 22
74 Tools Strictness annotations Don t be too tail-recursive: consider foldr: foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) 22
75 Tools Strictness annotations Don t be too tail-recursive: consider foldr: foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) Use lazy containers with strict contents 22
76 Laziness Summary ADVANTAGES CODE RE-USE by not committing to a strategy too early PERFORMANCE by not wasting work DISADVANTAGES PURITY is required SPACE USAGE is difficult to reason about DEBUGGERS are more difficult to implement 23
77 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 24
78 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 24
79 Overloading Ordering data Tree a = Empty Node (Tree a) a (Tree a) 24
80 Overloading Ordering data Tree a = Empty Node (Tree a) a (Tree a) insert :: Tree a -> a -> Tree a insert Empty x = Node Empty x Empty insert (Node l y r) x = if x <= y then Node (insert x l) y r else Node l y (insert x r) 24
81 Overloading Ordering data Tree a = Empty Node (Tree a) a (Tree a) insert :: Tree a -> a -> Tree a insert Empty x = Node Empty x Empty insert (Node l y r) x = if x <= y then Node (insert x l) y r else Node l y (insert x r) What does this mean? 24
82 In Scala abstract class Tree[A] case class Empty[A]() extends Tree[A] case class Node[A]( left: Tree[A], x : A, right: Tree[A] ) extends Tree[A]
83 In Scala abstract class Tree[A] case class Empty[A]() extends Tree[A] case class Node[A]( left: Tree[A], x : A, right: Tree[A] ) extends Tree[A] def insert[a <: Ordered[A]](t : Tree[A], x : A): Tree[A] = t match { case Empty() => Node(Empty(), x, Empty() case Node(l, y, r) => if (x <= y) Node(insert(l, x), y, r) else Node(l, y, insert(r, x)) }
84 Type Classes For a given type, provide: Operations on the type Default implementations of some operations data Ordering = LT EQ GT class Ord a where compare :: a -> a -> Ordering (>) :: a -> a -> Bool a > b = case compare a b of GT -> True _ -> False... 26
85 Type Class Constraints data Tree a = Empty Node (Tree a) a (Tree a) insert :: (Ord a) => Tree a -> a -> Tree a insert Empty x = Node Empty x Empty insert (Node l y r) x = if x <= y then Node (insert x l) y r else Node l y (insert x r) 27
86 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 28
87 Eq class Eq a where (==) : a -> a -> Bool x == y = not (x /= y) (/=) : a -> a -> Bool x /= y = not (x == y) 28
88 Eq class Eq a where (==) : a -> a -> Bool x == y = not (x /= y) (/=) : a -> a -> Bool x /= y = not (x == y) Default implementations: clients need only define enough! 28
89 Ord class (Eq a) => Ord a where compare :: a -> a -> Ordering (<), (<=), (>=), (>) :: a -> a -> Bool max, min :: a -> a -> a -- plus default methods... 29
90 Ord class (Eq a) => Ord a where compare :: a -> a -> Ordering (<), (<=), (>=), (>) :: a -> a -> Bool max, min :: a -> a -> a -- plus default methods... Superclass constraint: all Ord must have Eq 29
91 Under the Hood class Num a where (+), (*) :: a -> a -> a neg :: a -> a instance Num Int where (+) = addint (*) = mulint neg = negint instance Num Float where (+) = addfloat (*) = mulfloat neg = negfloat sumsquares :: (Num a) => a -> a -> a sumsquares x y = x * x + y * y
92 Under the Hood data NumD a = NumDict (a -> a -> a) (a -> a -> a) (a -> a) plus (NumDict p t n) = p times (NumDict p t n) = t neg (NumDict p t n) = n instance Num Int where (+) = addint (*) = mulint neg = negint instance Num Float where (+) = addfloat (*) = mulfloat neg = negfloat sumsquares :: (Num a) => a -> a -> a sumsquares x y = x * x + y * y
93 Under the Hood data NumD a = NumDict (a -> a -> a) (a -> a -> a) (a -> a) plus (NumDict p t n) = p times (NumDict p t n) = t neg (NumDict p t n) = n numint = NumDict addint mulint negint instance Num Float where (+) = addfloat (*) = mulfloat neg = negfloat sumsquares :: (Num a) => a -> a -> a sumsquares x y = x * x + y * y
94 Under the Hood data NumD a = NumDict (a -> a -> a) (a -> a -> a) (a -> a) plus (NumDict p t n) = p times (NumDict p t n) = t neg (NumDict p t n) = n numint = NumDict addint mulint negint numfloat = NumDict addfloat mulfloat negfloat sumsquares :: (Num a) => a -> a -> a sumsquares x y = x * x + y * y
95 Under the Hood data NumD a = NumDict (a -> a -> a) (a -> a -> a) (a -> a) plus (NumDict p t n) = p times (NumDict p t n) = t neg (NumDict p t n) = n numint = NumDict addint mulint negint numfloat = NumDict addfloat mulfloat negfloat sumsquares :: (Num a) -> a -> a -> a sumsquares x y = x * x + y * y
96 Under the Hood data NumD a = NumDict (a -> a -> a) (a -> a -> a) (a -> a) plus (NumDict p t n) = p times (NumDict p t n) = t neg (NumDict p t n) = n numint = NumDict addint mulint negint numfloat = NumDict addfloat mulfloat negfloat sumsquares :: (Num a) -> a -> a -> a sumsquares dict x y = plus dict (times dict x y) (times dict x y)
97 Under the Hood data NumD a = NumDict (a -> a -> a) (a -> a -> a) (a -> a) plus (NumDict p t n) = p times (NumDict p t n) = t neg (NumDict p t n) = n numint = NumDict addint mulint negint numfloat = NumDict addfloat mulfloat negfloat sumsquares :: (Num a) -> a -> a -> a sumsquares dict x y = plus dict (times dict x y) (times dict x y)
98 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 36
99 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 36
100 Computing with State Generating labels: let lastlab = ref (-1) newlabel () = lastlab :=!lastlab + 1 "label" + (!lastlab.tostring()) 36
101 Computing with State, Purely Return a new state after updating: startlabel = -1 newlabel old = let next = old + 1 ("label" ++ show next, next) 37
102 Computing with State, Purely Return a new state after updating: startlabel = -1 newlabel old = let next = old + 1 ("label" ++ show next, next) Easy to forget 37
103 Computing with State, Purely Return a new state after updating: startlabel = -1 newlabel old = let next = old + 1 ("label" ++ show next, next) Easy to forget Difficult to read 37
104 Computing with State, Purely Return a new state after updating: startlabel = -1 newlabel old = let next = old + 1 ("label" ++ show next, next) Easy to forget Difficult to read Risk of time travel 37
105 State as a Container data WithLabels a = Labeled (Int -> (a, Int)) 38
106 State as a Container data WithLabels a = Labeled (Int -> (a, Int)) only :: a -> WithLabels a only x = Labeled (\i -> (x, i)) 38
107 State as a Container data WithLabels a = Labeled (Int -> (a, Int)) only :: a -> WithLabels a only x = Labeled (\i -> (x, i)) get :: WithLabels Int get = Labeled (\i -> (i, i)) 38
108 State as a Container data WithLabels a = Labeled (Int -> (a, Int)) only :: a -> WithLabels a only x = Labeled (\i -> (x, i)) get :: WithLabels Int get = Labeled (\i -> (i, i)) set :: Int -> WithLabels () set i = Labeled (\j -> ((), i)) 38
109 State as a Container data WithLabels a = Labeled (Int -> (a, Int)) only :: a -> WithLabels a only x = Labeled (\i -> (x, i)) get :: WithLabels Int get = Labeled (\i -> (i, i)) set :: Int -> WithLabels () set i = Labeled (\j -> ((), i)) run :: Int -> WithLabels a -> a run i (Labeled comp) = fst (comp i) 38
110 State as a Container data WithLabels a = Labeled (Int -> (a, Int)) only :: a -> WithLabels a only x = Labeled (\i -> (x, i)) get :: WithLabels Int get = Labeled (\i -> (i, i)) set :: Int -> WithLabels () set i = Labeled (\j -> ((), i)) run :: Int -> WithLabels a -> a run i (Labeled comp) = fst (comp i) 38
111 Threading State step :: WithLabels a -> (a -> WithLabels b) -> WithLabels b
112 Threading State step :: WithLabels a -> (a -> WithLabels b) -> WithLabels b step (Labeled comp) next = Labeled (\i -> let (x, j) = comp i (Labeled cont) = next x in cont j)
113 Generating Labels, purely getlabel :: WithLabels String getlabel = get 40
114 Generating Labels, purely getlabel :: WithLabels String getlabel = get step (\i -> let lab = "label" ++ show i in set (i + 1) 40
115 Generating Labels, purely getlabel :: WithLabels String getlabel = get step (\i -> let lab = "label" ++ show i in set (i + 1) step (\() -> only lab)) 40
116 Generating Labels, purely getlabel :: WithLabels String getlabel = get step (\i -> let lab = "label" ++ show i in set (i + 1) step (\() -> only lab)) -- At REPL > run 0 (getlabel step (\ -> getlabel)) "label1" 40
117
118 Sugar to the rescue! The code getlabel :: WithLabels String getlabel = get step (\i -> let lab = "label" ++ show i in set (i + 1) step (\() -> only lab)) is much better when written: getlabel :: WithLabels String getlabel = do i <- get let lab = "label" ++ show i set (i + 1) return lab 42
119 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 43
120 Monads class Monad m where return : a -> m a (>>=) : m a -> (a -> m b) -> m b (>>) : m a -> m b -> m b x >> y = x >>= (\_ -> y) 43
121 Monads class Monad m where return : a -> m a (>>=) : m a -> (a -> m b) -> m b (>>) : m a -> m b -> m b x >> y = x >>= (\_ -> y) m has kind * -> * 43
122 Monads class Monad m where return : a -> m a (>>=) : m a -> (a -> m b) -> m b (>>) : m a -> m b -> m b x >> y = x >>= (\_ -> y) m has kind * -> * (>>=) looks like the Scala signature def flatmap[b](f: A => C[B]): C[B] 43
123 Monads class Monad m where return : a -> m a (>>=) : m a -> (a -> m b) -> m b (>>) : m a -> m b -> m b x >> y = x >>= (\_ -> y) m has kind * -> * (>>=) looks like the Scala signature def flatmap[b](f: A => C[B]): C[B] Laws: Left identity: return x >>= f f x 43
124 Monads class Monad m where return : a -> m a (>>=) : m a -> (a -> m b) -> m b (>>) : m a -> m b -> m b x >> y = x >>= (\_ -> y) m has kind * -> * (>>=) looks like the Scala signature def flatmap[b](f: A => C[B]): C[B] Laws: Left identity: return x >>= f f x Right identity: x >>= return x 43
125 Monads class Monad m where return : a -> m a (>>=) : m a -> (a -> m b) -> m b (>>) : m a -> m b -> m b x >> y = x >>= (\_ -> y) m has kind * -> * (>>=) looks like the Scala signature def flatmap[b](f: A => C[B]): C[B] Laws: Left identity: return x >>= f f x Right identity: x >>= return x Associativity: (x >>= f) >>= g x >>= (\i -> f i >>= g) 43
126 Desugaring do do x ==> x 44
127 Desugaring do do x ==> x do x rest ==> x >> do y 44
128 Desugaring do do x ==> x do x rest do i <- x rest ==> x >> do y ==> x >>= (\i -> do rest) 44
129 Desugaring do do x ==> x do x rest do i <- x rest ==> x >> do y ==> x >>= (\i -> do rest) do let i = x rest ==> let i = x in do rest 44
130 WithLabels is a Monad! instance Monad WithLabels where return = only (>>=) = step 45
131 Desugaring getlabel getlabel :: WithLabels String getlabel = do i <- get let lab = "label" ++ show i set (i + 1) return lab getlabel :: WithLabels String getlabel = get >>= (\i -> let lab = "label" ++ show i in set (i + 1) >> return lab) 46
132 Example Monads instance Monad [] where return x = [x] [] >>= f = [] (x:xs) >>= f = f x ++ (xs >>= f) 47
133 Example Monads instance Monad [] where return x = [x] [] >>= f = [] (x:xs) >>= f = f x ++ (xs >>= f) instance Monad Maybe where return x = Just x (Just x) >>= f = f x Nothing >>= f = Nothing 47
134 Example Monads instance Monad [] where return x = [x] [] >>= f = [] (x:xs) >>= f = f x ++ (xs >>= f) instance Monad Maybe where return x = Just x (Just x) >>= f = f x Nothing >>= f = Nothing instance Monad (Either a) where return x = Right x (Left err) >>= f = Left err (Right x) >>= f = f x 47
135 Monadic I/O I/O takes the world as a parameter and constructs a new world! 48
136 Monadic I/O Use a monad to thread the world through computation: data IO a = MkIO (World -> (a, World)) instance Monad IO where return x = MkIO (\w -> (x, w)) (MkIO x) >>= y = MkIO (\w -> let (res, newworld) = x w (MkIO cont) = y res in cont newworld) User code can t pattern-match MkIO it only has return and (>>=) so no shenanigans with the World. 49
137 Hello, world main :: IO () main = do putstrln "Who are you?" name <- getline putstrln ("Hello, " ++ name) 50
138 Hello, world main :: IO () main = do putstrln "Who are you?" name <- getline putstrln ("Hello, " ++ name) main :: IO () main = putstrln >>= (\ -> getline >>= (\name -> putstrln ("Hello, " ++ name))) Not a world in sight... 50
139 Monad Libraries mapm :: Monad m => (a -> m b) -> [a] -> m [b] mapm_ :: Monad m => (a -> m b) -> [a] -> m () 51
140 Monad Libraries mapm :: Monad m => (a -> m b) -> [a] -> m [b] mapm_ :: Monad m => (a -> m b) -> [a] -> m () sequence :: Monad m => [m a] -> m [a] sequence_ :: Monad m => [m a] -> m () 51
141 Monad Libraries mapm :: Monad m => (a -> m b) -> [a] -> m [b] mapm_ :: Monad m => (a -> m b) -> [a] -> m () sequence :: Monad m => [m a] -> m [a] sequence_ :: Monad m => [m a] -> m () when :: Monad m => Bool -> m () -> m () 51
142 Monads in.net LINQ is inspired by Haskell monads: public static IEnumerable<B> SelectMany<A, B>( this IEnumerable<A> source, Func<A, IEnumerable<B>> selector ) vs (>>=) :: m a -> (a -> m b) -> m b 52
143 Higher-Order Types at Work.NET loses type information Select and SelectMany return IEnumerable Monad preserves type information Being a monad is a property of type constructors, while being IEnumerable is a merely property of types. 53
144 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 54
145 Learn More RESOURCES Learn You a Haskell for Great Good Hoogle lets you search libraries by type PROJECT POSSIBILITIES Idris is an advanced open-source functional language with a compiler written in Haskell. We re a good source of projects! 54
146 Overview HELLO, WORLD BASIC SYNTAX LAZY EVALUATION Laziness Space Leaks TYPE CLASSES Overloading Examples GETTING THINGS DONE COMPUTING WITH STATE Monads in Haskell LEARN MORE WHAT S NEXT 55
147 What s Next Today, 13:00-13:50: Demonstration in Aud. 3 of starting project with fsyacc and fslex, from scratch (Ahmad is in 2A54) Spørgetime on Friday, December 20 from 10 AM to noon in Aud. 3 Exam: may need to be turned in on paper news to follow. Assignment deadline is Wednesday, December 4 55
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
Standard prelude. Appendix A. A.1 Classes
Appendix A Standard prelude In this appendix we present some of the most commonly used definitions from the standard prelude. For clarity, a number of the definitions have been simplified or modified from
Functional Programming Mid-term exam Tuesday 3/10/2017
Functional Programming Mid-term exam Tuesday 3/10/2017 Name: Student number: Before you begin: Do not forget to write down your name and student number above. If necessary, explain your answers in English.
INTRODUCTION TO HASKELL
INTRODUCTION TO HASKELL PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/81 HASKELL: A PURELY FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be
Haskell Introduction Lists Other Structures Data Structures. Haskell Introduction. Mark Snyder
Outline 1 2 3 4 What is Haskell? Haskell is a functional programming language. Characteristics functional non-strict ( lazy ) pure (no side effects*) strongly statically typed available compiled and interpreted
(ii) Define a function ulh that takes a list xs, and pairs each element with all other elements in xs.
EXAM FUNCTIONAL PROGRAMMING Tuesday the 1st of October 2016, 08.30 h. - 10.30 h. Name: Student number: Before you begin: Do not forget to write down your name and student number above. If necessary, explain
Lecture 4: Higher Order Functions
Lecture 4: Higher Order Functions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 26, 2017 HIGHER ORDER FUNCTIONS The order of a function
Haskell Types, Classes, and Functions, Currying, and Polymorphism
1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Types, Classes, and Functions, Currying, and Polymorphism 2 Types A type is a collection of related values. For example, Bool contains the
Introduction to Haskell
Introduction to Haskell Matt Mullins Texas A&M Computing Society October 6, 2009 Matt Mullins (TACS) Introduction to Haskell October 6, 2009 1 / 39 Outline Introduction to Haskell Functional Programming
Part 0. A (Not So) Brief Introduction to Haskell
Part 0 A (Not So) Brief Introduction to Haskell CSCI 3110 Code Fall 2015 1 Introduction This introduction discusses the most important aspects of programming in Haskell hopefully sufficiently well for
Haskell: From Basic to Advanced. Part 2 Type Classes, Laziness, IO, Modules
Haskell: From Basic to Advanced Part 2 Type Classes, Laziness, IO, Modules Qualified types In the types schemes we have seen, the type variables were universally quantified, e.g. ++ :: [a] -> [a] -> [a]
Higher Order Functions in Haskell
Higher Order Functions in Haskell Evan Misshula 2018-09-10 Outline Curried Functions Curried comparison Example partial application partial application of a string function Returned functions ZipWith flip
A general introduction to Functional Programming using Haskell
A general introduction to Functional Programming using Haskell Matteo Rossi Dipartimento di Elettronica e Informazione Politecnico di Milano rossi@elet.polimi.it 1 Functional programming in a nutshell
301AA - Advanced Programming
301AA - Advanced Programming Lecturer: Andrea Corradini andrea@di.unipi.it h;p://pages.di.unipi.it/corradini/ Course pages: h;p://pages.di.unipi.it/corradini/dida@ca/ap-18/ AP-2018-19: Algebraic Datatypes
Haskell Overview II (2A) Young Won Lim 8/9/16
(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Background Operators (1E) Young Won Lim 7/7/18
Background Operators (1E) Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
CS 457/557: Functional Languages
CS 457/557: Functional Languages Lists and Algebraic Datatypes Mark P Jones Portland State University 1 Why Lists? Lists are a heavily used data structure in many functional programs Special syntax is
Background Type Classes (1B) Young Won Lim 6/28/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
According to Larry Wall (designer of PERL): a language by geniuses! for geniuses. Lecture 7: Haskell. Haskell 98. Haskell (cont) - Type-safe!
Lecture 7: Haskell CSC 131 Fall, 2014 Kim Bruce According to Larry Wall (designer of PERL): a language by geniuses for geniuses He s wrong at least about the latter part though you might agree when we
CPL 2016, week 10. Clojure functional core. Oleg Batrashev. April 11, Institute of Computer Science, Tartu, Estonia
CPL 2016, week 10 Clojure functional core Oleg Batrashev Institute of Computer Science, Tartu, Estonia April 11, 2016 Overview Today Clojure language core Next weeks Immutable data structures Clojure simple
Functional Programming. Overview. Topics. Definition n-th Fibonacci Number. Graph
Topics Functional Programming Christian Sternagel Harald Zankl Evgeny Zuenko Department of Computer Science University of Innsbruck WS 2017/2018 abstract data types, algebraic data types, binary search
Principles of Programming Languages (H)
Principles of Programming Languages (H) Matteo Pradella December 1, 2017 Matteo Pradella Principles of Programming Languages (H) December 1, 2017 1 / 105 Overview 1 Introduction on purity and evaluation
CSCE 314 Programming Languages
CSCE 314 Programming Languages Haskell: Higher-order Functions Dr. Hyunyoung Lee 1 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as
Haskell & functional programming, some slightly more advanced stuff. Matteo Pradella
Haskell & functional programming, some slightly more advanced stuff Matteo Pradella pradella@elet.polimi.it IEIIT, Consiglio Nazionale delle Ricerche & DEI, Politecnico di Milano PhD course @ UniMi - Feb
Shell CSCE 314 TAMU. Higher Order Functions
1 CSCE 314: Programming Languages Dr. Dylan Shell Higher Order Functions 2 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as a result.
Haskell An Introduction
Haskell An Introduction What is Haskell? General purpose Purely functional No function can have side-effects IO is done using special types Lazy Strongly typed Polymorphic types Concise and elegant A First
Imperative languages
Imperative languages Von Neumann model: store with addressable locations machine code: effect achieved by changing contents of store locations instructions executed in sequence, flow of control altered
Programming Languages Fall 2013
Programming Languages Fall 2013 Lecture 2: types Prof. Liang Huang huang@qc.cs.cuny.edu Recap of Lecture 1 functional programming vs. imperative programming basic Haskell syntax function definition lazy
Functional Programming and Haskell
Functional Programming and Haskell Tim Dawborn University of Sydney, Australia School of Information Technologies Tim Dawborn Functional Programming and Haskell 1/22 What are Programming Paradigms? A programming
An introduction to functional programming. July 23, 2010
An introduction to functional programming July 23, 2010 About Outline About About What is functional programming? What is? Why functional programming? Why? is novel. is powerful. is fun. About A brief
Functional Programming for Logicians - Lecture 1
Functional Programming for Logicians - Lecture 1 Functions, Lists, Types Malvin Gattinger 4 June 2018 module L1 where Introduction Who is who Course website: https://malv.in/2018/funcproglog/ Malvin Gattinger
Haskell: From Basic to Advanced. Part 3 A Deeper Look into Laziness
Haskell: From Basic to Advanced Part 3 A Deeper Look into Laziness Haskell is a lazy language Laziness again A particular function argument is only evaluated when it is needed, and if it is needed then
Haske k ll An introduction to Functional functional programming using Haskell Purely Lazy Example: QuickSort in Java Example: QuickSort in Haskell
Haskell An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dk The most popular purely functional, lazy programming language Functional programming language : a program
EDAF40. 2nd June :00-19:00. WRITE ONLY ON ONE SIDE OF THE PAPER - the exams will be scanned in and only the front/ odd pages will be read.
EDAF40 2nd June 2017 14:00-19:00 WRITE ONLY ON ONE SIDE OF THE PAPER - the exams will be scanned in and only the front/ odd pages will be read. DO NOT WRITE WITH OTHER COLOUR THAN BLACK - coloured text
Lecture 5: Lazy Evaluation and Infinite Data Structures
Lecture 5: Lazy Evaluation and Infinite Data Structures Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense October 3, 2017 How does Haskell evaluate a
Overloading, Type Classes, and Algebraic Datatypes
Overloading, Type Classes, and Algebraic Datatypes Delivered by Michael Pellauer Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. September 28, 2006 September 28, 2006 http://www.csg.csail.mit.edu/6.827
Advanced Programming Handout 7. Monads and Friends (SOE Chapter 18)
Advanced Programming Handout 7 Monads and Friends (SOE Chapter 18) The Type of a Type In previous chapters we discussed: Monomorphic types such as Int, Bool, etc. Polymorphic types such as [a], Tree a,
Practical Haskell. An introduction to functional programming. July 21, Practical Haskell. Juan Pedro Villa-Isaza. Introduction.
Practical Practical An introduction to functional programming July 21, 2011 Contents Practical Practical is fun, and that s what it s all about! Even if seems strange to you at first, don t give up. Learning
An introduction introduction to functional functional programming programming using usin Haskell
An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dkau Haskell The most popular p purely functional, lazy programming g language Functional programming language : a program
Logic - CM0845 Introduction to Haskell
Logic - CM0845 Introduction to Haskell Diego Alejandro Montoya-Zapata EAFIT University Semester 2016-1 Diego Alejandro Montoya-Zapata (EAFIT University) Logic - CM0845 Introduction to Haskell Semester
Advanced features of Functional Programming (Haskell)
Advanced features of Functional Programming (Haskell) Polymorphism and overloading January 10, 2017 Monomorphic and polymorphic types A (data) type specifies a set of values. Examples: Bool: the type of
An Introduction to Programming in Haskell. Gabriel J. Ferrer Hendrix College
An Introduction to Programming in Haskell Gabriel J. Ferrer Hendrix College Overview Functional programming Property testing Iteration Type system I/O Installation Go to: http://www.haskell.org/ Download
Programming Paradigms
PP 2017/18 Unit 12 Functions and Data Types in Haskell 1/45 Programming Paradigms Unit 12 Functions and Data Types in Haskell J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE
JVM ByteCode Interpreter
JVM ByteCode Interpreter written in Haskell (In under 1000 Lines of Code) By Louis Jenkins Presentation Schedule ( 15 Minutes) Discuss and Run the Virtual Machine first
Programming in Haskell Aug Nov 2015
Programming in Haskell Aug Nov 2015 LECTURE 23 NOVEMBER 12, 2015 S P SURESH CHENNAI MATHEMATICAL INSTITUTE Summary of IO Actions of type IO t1, t1 -> IO t2, t1 -> t2 -> IO t3 etc. As opposed to pure functions
Haskell 101. (Version 1 (July 18, 2012)) Juan Pedro Villa Isaza
Haskell 101 (Version 1 (July 18, 2012)) Juan Pedro Villa Isaza Haskell 101: Contents Introduction Tutorial Homework Bibliography Haskell 101: Contents Introduction Tutorial Homework Bibliography Haskell
CSCE 314 Programming Languages
CSCE 314 Programming Languages Final Review Part I Dr. Hyunyoung Lee 1 Programming Language Characteristics Different approaches to describe computations, to instruct computing devices E.g., Imperative,
Functional Programming
Functional Programming Monadic Prelude Jevgeni Kabanov Department of Computer Science University of Tartu Introduction Previously on Functional Programming Monadic laws Monad class (>>= and return) MonadPlus
CS 340 Spring 2019 Midterm Exam
CS 340 Spring 2019 Midterm Exam Instructions: This exam is closed-book, closed-notes. Electronic devices of any kind are not permitted. Write your final answers, tidily, in the boxes provided. Scratch
Principles of Programming Languages
Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp- 14/ Prof. Andrea Corradini Department of Computer Science, Pisa Introduc;on to Hakell Lesson 27! 1 The origins: ML programming
Principles of Programming Languages, 3
Principles of Programming Languages, 3 Matteo Pradella May 2015 Matteo Pradella Principles of Programming Languages, 3 May 2015 1 / 94 1 Introduction on purity and evaluation 2 Haskell Matteo Pradella
CS 320: Concepts of Programming Languages
CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 08: Type Classes o o Review: What is a type class? Basic Type Classes: Eq, Ord, Enum, Integral,
Introduction to Functional Programming in Haskell 1 / 56
Introduction to Functional Programming in Haskell 1 / 56 Outline Why learn functional programming? The essence of functional programming What is a function? Equational reasoning First-order vs. higher-order
INDEX. Symbols & Numbers. Learn You a Haskell for Great Good! 2011 by Miran Lipovača
INDEX Symbols & Numbers && (double ampersand) as Boolean operator conjunction, 2 using with folds and lists, 78 79 '(apostrophe) using with functions, 7 using with types, 149 150 * (asterisk) as multiplication
CSC324 Principles of Programming Languages
CSC324 Principles of Programming Languages http://mcs.utm.utoronto.ca/~324 November 14, 2018 Today Final chapter of the course! Types and type systems Haskell s type system Types Terminology Type: set
Optimising Functional Programming Languages. Max Bolingbroke, Cambridge University CPRG Lectures 2010
Optimising Functional Programming Languages Max Bolingbroke, Cambridge University CPRG Lectures 2010 Objectives Explore optimisation of functional programming languages using the framework of equational
Haskell: From Basic to Advanced. Haskell buzzwords. Hello, World! History. Haskell 98 / Haskell 2010 GHC
Haskell: From Basic to Advanced Haskell buzzwords Part 1 Basic Language Functional Pure Lazy Strong static typing Type polymorphism Type classes Monads Haskell 98 / Haskell 2010 GHC Glasgow Haskell Compiler
Haskell Overview II (2A) Young Won Lim 8/23/16
(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
CS 320 Midterm Exam. Fall 2018
Name: BU ID: CS 320 Midterm Exam Fall 2018 Write here the number of the problem you are skipping: You must complete 5 of the 6 problems on this exam for full credit. Each problem is of equal weight. Please
Introduction to Functional Programming and Haskell. Aden Seaman
Introduction to Functional Programming and Haskell Aden Seaman Functional Programming Functional Programming First Class Functions Expressions (No Assignment) (Ideally) No Side Effects Different Approach
Informatics 1 Functional Programming Lecture 12. Data Abstraction. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 12 Data Abstraction Don Sannella University of Edinburgh Part I Sets as lists without abstraction We will look again at our four ways of implementing sets.
CMSC 330: Organization of Programming Languages. Functional Programming with Lists
CMSC 330: Organization of Programming Languages Functional Programming with Lists CMSC330 Spring 2018 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as
Haskell Types COMP360
Haskell Types COMP360 No computer has ever been designed that is ever aware of what it's doing; but most of the time, we aren't either. Marvin Minsky Haskell Programming Assignment A Haskell programming
Lecture 2: List algorithms using recursion and list comprehensions
Lecture 2: List algorithms using recursion and list comprehensions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 12, 2017 Expressions, patterns
Informatics 1 Functional Programming Lecture 11. Data Representation. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 11 Data Representation Don Sannella University of Edinburgh Part I Complexity t = n vs t = n 2 10.4 9.6 8.8 8 7.2 6.4 5.6 4.8 4 3.2 2.4 1.6 0.8 0 0.8 1.6 2.4
GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]
![GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]](/thumbs/78/76904283.jpg "GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]")
GADTs Advanced functional programming - Lecture 7 Wouter Swierstra and Alejandro Serrano 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree
Little and not so big bits of Haskell
Little and not so big bits of Haskell D. Renault Haskell (small) School LaBRI October 2015, v. 1.2.1 D. Renault (LaBRI) Little and not so big bits of Haskell October 2015, v. 1.2.1 1 / 45 1990 - A committee
CS 440: Programming Languages and Translators, Spring 2019 Mon
Haskell, Part 4 CS 440: Programming Languages and Translators, Spring 2019 Mon 2019-01-28 More Haskell Review definition by cases Chapter 6: Higher-order functions Revisit currying map, filter Unnamed
PROGRAMMING IN HASKELL. CS Chapter 6 - Recursive Functions
PROGRAMMING IN HASKELL CS-205 - Chapter 6 - Recursive Functions 0 Introduction As we have seen, many functions can naturally be defined in terms of other functions. factorial :: Int Int factorial n product
Introduction to Haskell
Introduction to Haskell Frederick Ross and lots of folk from #haskell April 26, 2008 1 Preliminaries Source code in Haskell is organized into modules. In today s environments, modules correspond to files,
GADTs. Alejandro Serrano. AFP Summer School. [Faculty of Science Information and Computing Sciences]
![GADTs. Alejandro Serrano. AFP Summer School. [Faculty of Science Information and Computing Sciences]](/thumbs/95/124893351.jpg "GADTs. Alejandro Serrano. AFP Summer School. [Faculty of Science Information and Computing Sciences]")
GADTs AFP Summer School Alejandro Serrano 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree a) This definition introduces: 3 A datatype data
Exercises on ML. Programming Languages. Chanseok Oh
Exercises on ML Programming Languages Chanseok Oh chanseok@cs.nyu.edu Dejected by an arcane type error? - foldr; val it = fn : ('a * 'b -> 'b) -> 'b -> 'a list -> 'b - foldr (fn x=> fn y => fn z => (max
Programming with Math and Logic
.. Programming with Math and Logic an invitation to functional programming Ed Morehouse Wesleyan University The Plan why fp? terms types interfaces The What and Why of Functional Programming Computing
HIGHER-ORDER FUNCTIONS
5 HIGHER-ORDER FUNCTIONS Haskell functions can take functions as parameters and return functions as return values. A function that does either of these things is called a higher-order function. Higher-order
CMSC 330: Organization of Programming Languages. Functional Programming with Lists
CMSC 330: Organization of Programming Languages Functional Programming with Lists 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as a linked data structure
CS 360: Programming Languages Lecture 10: Introduction to Haskell
CS 360: Programming Languages Lecture 10: Introduction to Haskell Geoffrey Mainland Drexel University Thursday, February 5, 2015 Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia
Introduction. Wouter Swierstra. Applied functional programming. Faculty of Science Information and Computing Sciences
Introduction Applied functional programming Wouter Swierstra 1 Welcome to the Utrecht AFP Summer School 2017 2 This morning Introduce myself and the other lecturers Overview of the course Basic Haskell
Course year Typeclasses and their instances
Course year 2016-2017 Typeclasses and their instances Doaitse Swierstra and Atze Dijkstra with extra s Utrecht University September 29, 2016 1. The basics 2 Overloading versus parametric polymorphism 1
Informatics 1 Functional Programming Lecture 7. Map, filter, fold. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 7 Map, filter, fold Don Sannella University of Edinburgh Part I Map Squares *Main> squares [1,-2,3] [1,4,9] squares :: [Int] -> [Int] squares xs [ x*x x
Topic 6: Partial Application, Function Composition and Type Classes
Topic 6: Partial Application, Function Composition and Type Classes Recommended Exercises and Readings From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 11.11, 11.12 12.30, 12.31,
Topic 6: Partial Application, Function Composition and Type Classes
Topic 6: Partial Application, Function Composition and Type Classes 1 Recommended Exercises and Readings From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 11.11, 11.12 12.30, 12.31,
Haskell Overview II (2A) Young Won Lim 9/26/16
(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published
Monads seen so far: IO vs Gen
Monads David Sands Monads seen so far: IO vs Gen IO A Gen A Instructions to build a value of type A by interacting with the operating system Instructions to create a random value of type A Run by the ghc
Monads in Haskell. Nathanael Schilling. December 12, 2014
Monads in Haskell Nathanael Schilling December 12, 2014 Abstract In Haskell, monads provide a mechanism for mapping functions of the type a -> m b to those of the type m a -> m b. This mapping is dependent
A tour of the Haskell Prelude
A tour of the Haskell Prelude Bernie Pope 2001 1 Haskell The Haskell language was conceived during a meeting held at the 1987 Functional Programming and Computer Architecture conference (FPCA 87). At the
SCHEME 10 COMPUTER SCIENCE 61A. July 26, Warm Up: Conditional Expressions. 1. What does Scheme print? scm> (if (or #t (/ 1 0)) 1 (/ 1 0))
SCHEME 0 COMPUTER SCIENCE 6A July 26, 206 0. Warm Up: Conditional Expressions. What does Scheme print? scm> (if (or #t (/ 0 (/ 0 scm> (if (> 4 3 (+ 2 3 4 (+ 3 4 (* 3 2 scm> ((if (< 4 3 + - 4 00 scm> (if
Type-indexed functions in Generic Haskell
Type-indexed functions in Generic Haskell Johan Jeuring September 15, 2004 Introduction Today I will talk about: a Types of polymorphism. b Type-indexed functions. c Dependencies. Read about b, and c in
Lecture 10 September 11, 2017
Programming in Haskell S P Suresh http://www.cmi.ac.in/~spsuresh Lecture 10 September 11, 2017 Combining elements sumlist :: [Int] -> Int sumlist [] = 0 sumlist (x:xs) = x + (sumlist xs) multlist :: [Int]
Haskell Revision and Exercises
and Exercises April 10, 2017 Martin Perešíni Haskell Revision and Exercises April 10, 2017 1 / 53 Content Content Content Haskell Revision Types and Typeclasses Types of Functions List of types Syntax
301AA - Advanced Programming [AP-2017]
![301AA - Advanced Programming [AP-2017]](/thumbs/95/122814353.jpg "301AA - Advanced Programming [AP-2017]")
301AA - Advanced Programming [AP-2017] Lecturer: Andrea Corradini andrea@di.unipi.it Tutor: Lillo GalleBa galleba@di.unipi.it Department of Computer Science, Pisa Academic Year 2017/18 AP-2017-16: Haskell,
CSE 130 [Winter 2014] Programming Languages
![CSE 130 [Winter 2014] Programming Languages](/thumbs/72/67149502.jpg "CSE 130 [Winter 2014] Programming Languages")
CSE 130 [Winter 2014] Programming Languages Higher-Order Functions! Ravi Chugh! Jan 23 Today s Plan A little more practice with recursion Base Pattern Base Expression Induction Pattern Induction Expression
CIS 120 Midterm I February 16, 2015 SOLUTIONS
CIS 120 Midterm I February 16, 2015 SOLUTIONS 1 1. Substitution semantics (18 points) Circle the final result of simplifying the following OCaml expressions, or Infinite loop if there is no final answer.
f() ! " Run a higher-priority task? ! " Yield the processor to another task because our ! " Use the processor for some other activity while
CS 410/510: Advanced Programming Continuing a Computation: Continuations Mark P Jones Portland State University 1 Standard nested function call pattern 2 Continuing a Computation: What might we want to
CS 410/510: Advanced Programming
CS 410/510: Advanced Programming Continuations Mark P Jones Portland State University 1 Continuing a Computation: f() g() h() Standard nested function call pattern 2 Continuing a Computation: f() g() h()
Functional Programming TDA 452, DIT 142
Chalmers Göteborgs Universitet 2016-04-07 Examiner: David Sands dave@chalmers.se. Answering questions on the day of the exam (at approx 15.00): Gregoire Detrez (tel: 073 55 69 550) and at other times by
Solution sheet 1. Introduction. Exercise 1 - Types of values. Exercise 2 - Constructors
Solution sheet 1 Introduction Please note that there can be other solutions than those listed in this document. This is a literate Haskell file which is available as PDF, as well as literate Haskell source
Documentation for the Idris Language. Version 0.99
Documentation for the Idris Language Version 0.99 Contents 1 The Idris Tutorial 2 2 Frequently Asked Questions 61 3 The Effects Tutorial 66 4 Theorem Proving 98 5 Language Reference 109 6 Tutorials on
Box-and-arrow Diagrams
Box-and-arrow Diagrams 1. Draw box-and-arrow diagrams for each of the following statements. What needs to be copied, and what can be referenced with a pointer? (define a ((squid octopus) jelly sandwich))
Programming Systems in Artificial Intelligence Functional Programming
Click to add Text Programming Systems in Artificial Intelligence Functional Programming Siegfried Nijssen 8/03/16 Discover thediscover world at the Leiden world University at Leiden University Overview
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of