Lazy Programming Lazy evaluation: an expression is evaluated if and only if its value is needed to compute the overall result Consequences: elements are generated on demand so that complex intermediate structures are not necessarily expensive, e.g., an intermediate list , expression may describe infinite data structures, e.g, the infinite list of all prime numbers, implications to program design.

Example + + h x y = x+x h (9-3) (h 12 15) (9-3) (9-3) (9-3) + (9-3) 6+6 12 (9-3) (9-3) + (9-3)

Calculation rules Pattern matching f :: [Int] -> [Int] -> Int f [] ys = 0 f xs [] = 0 f (x:xs) (y:ys) = x+y f [1..3] [1..3] f (1:[2..3]) [1..3] f (1:[2..3]) (1:[2..3]) 1+1 2

Calculation rules (cont’d) Guards f :: Int -> Int -> Int -> Int f m n p | m>=n && m>=p = m | n>=m && n>=p = n | otherwise = p f (2+3) (4-1) (3+9) ?? (2+3)>=(4-1) && (2+3)>=(3+9) ??  False && 3>=12 ??  5>=3 && 5>=(3+9) ??  False ??  True && 5>=(3+9) ?? otherwise ??  5>=(3+9) ??  True ??  5>=12  12 ??  False ?? 3>=5 && 3>=12

Calculation rules (cont’d) Local definitions f :: Int -> Int -> Int front (x:y:zs) = x+y f m n front [x] = x | notNil xs = front xs | otherwise = n notNil [] = False where xs = [m..n] notNil (_:_) = True f 3 5 ?? notNil xs  front xs ?? where where ?? xs = [3..5] xs = 3:[4..5] ??  3:[4..5]  3:4:[5] ??  notNil (3:[4..5])  3+4 ??  True  7

Calculation rules (cont’d) Evaluation order = order in which applications are evaluated when there is a choice. Evaluation is from the outside in: f1 e1 (f2 e2 17) Evaluation is from left to right: f1 e1 + f2 e2

List comprehension revisited List comprehension does not add any new programs to the Haskell language. It is a short-hand for a combination of multiple applications of map (concatMap) and filter. pyTriple n = [ (x,y,z) | x <- [2..n], y <- [x+1..n], z <- [y+1..n], x*x + y*y == z*z ] pyTriple’ n = concatMap (\x -> concatMap (\y -> concatMap (\z -> if x*x + y*y == z*z then [(x,y,z)] else []) [y+1..n]) [x+1..n]) [2..n] Evaluation rules: [ e | False , q2, …, qk]  [] [ e | v <- [], q2, …, qk]  [] [ e | v <- a:xs, q2, …, qk]  [ e{a/v} | q2{a/v}, …, qk{a/v} ] ++ [ e | v <- xs, q2, …, qk ]

Example [ x+y | x <- [1,2], isEven x, y <- [x..2*x] ] [ 1+y | isEven 1, y <- [1..2*1] ] ++ [ x+y | x <- [2], isEven x, y <- [2..2*2] ]  [ 1+y | False, y <- [1..2*1] ] ++  [ 2+y | isEven 2, y <- [2..2*2] ]  [ 2+y | True, y <- [2..2*2] ]  [ 2+y | y <- [2..2*2] ] [ 2+y | y <- 2:[3..2*2] ] [ 2+2 | ] ++ [ 2+y | y <- [3..2*2] ] [ 4 ] ++ [ 2+y | y <- [3..2*2] ] [ 4 ] ++ [ 2+y | y <- 3:[4..2*2] ] [ 4 ] ++ [ 2+3 | ] ++ [ 2+y | y <- [4..2*2] ] [ 4 ] ++ [ 5 ] ++ [ 2+y | y <- [4..2*2] ] [ 4,5 ] ++ [ 2+y | y <- [4..2*2] ] [ 4,5 ] ++ [ 2+y | y <- 4:[] ] [ 4,5 ] ++ [ 2+4 | ] ++ [ 2+y | y <- [] ] [ 4,5 ] ++ [ 6 ] ++ [ 2+y | y <- [] ] [ 4,5,6 ] ++ [ 2+y | y <- [] ] [ 4,5,6 ] ++ [] [ 4,5,6 ]

Infinite lists ones :: [Int] ones = 1 : ones [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,………………^C{Interrupted!}] addFirstTwo :: [Int] -> Int addFirstTwo (x:y:zs) = x+y addFirstTwo ones addFirstTwo (1:ones) addFirstTwo (1:1:ones) 1+1 2

Example: prime numbers 2 3 4 5 6 7 8 9 10 11 12 13 2 3 5 7 9 11 13 2 3 5 7 11 13 The sieve of Eratosthenes primes :: [Integer] primes = sieve [2..] sieve :: [Integer] -> [Integer] sieve (x:xs) = x:sieve [ y | y <- xs, y `mod` x > 0]

Example (cont’d) primes is an infinite list  be careful by using it 7 `elem` primes  True, but 6 `elem` primes does not terminate elemOrd :: Ord a => a -> [a] -> Bool elemOrd _ [] = False elemOrd y (x:xs) | x<y = elemOrd y xs | x==y = True | otherwise = False

Example: Generating random numbers nextRand :: Int -> Int nextRand n = (multiplier * n + increment) `mod` modulus randomSequence :: Int -> [Int] randomSequence = iterate nextRand seed, multiplier, increment, modulus :: Int seed = 17489 multiplier = 25173 increment = 13849 modulus = 65536 randonSequence seed  [17489,59134,9327,52468,43805,8378,18395,…

Another example pythagTriples = [ (x,y,z) | x <- [2..], y <- [x+1..], z <- [y+1..], x*x + y*y == z*z ] What is the result of pythagTriples? No output!!! pythagTriples' = [ (x,y,z) | z <- [4..], y <- [3..z-1], x <- [2..y-1], or use a function infiniteProduct :: [a] -> [b] –> [(a,b)]

Infinite elements in algebraic types data Tree a = Empty | Node a (Tree a) (Tree a) deriving Show replaceRightLeaf :: Tree a -> Tree a -> Tree a replaceRightLeaf t1 Empty = t1 replaceRightLeaf t1 (Node x t2 t3) = Node x t2 (replaceRightLeaf t1 t3) loopRightTree :: Tree a -> Tree a loopRightTree t = replaceRightLeaf (loopRightTree t) t tree1 = Node 1 (Node 2 Empty Empty) (Node 3 Empty Empty) loopRightTree tree1  Node 1 (Node 2 Empty Empty) (Node 3 Empty (Node 1 (Node 2 Empty Empty) (Node 3 Empty (Node 1 (Node 2 Empty Empty) (Node 3 Empty …