1. PPL
Sequence Interface

3. Midterm 2011

5. (define make-tree
(λ (value children)
(λ (sel)
(sel value children))))
(define root-value
(λ (tree)
(tree (λ (value children)
(value)))))
(define tree-children
(children)))))

6. The Sequence Interface
Consider the following Java code:
int[] mySequence = new int[] {1,2,3,4};
for (int i=0; i<mySequence.length; i++) {
System.out.println(mySequence[i]); }
Iterating over this sequence is coupled with its implementation.

7. The Sequence Interface
A little better:
List<Integer> mySequence = new LinkedList<> {1,2,3,4};
foreach (int j : mySequence) {
System.out.println(j); }
But still not perfect.

8. The Sequence Interface
OOP languages support collections
FP is better: sequence operations
Java 8 new feature is sequence operations… Scheme had it for years!

9. What is Sequence Interface?
ADT for lists
In other words: a barrier between clients running sequence applications and their implementations
Abstracts-away element by element manipulation

10. Map
Applies a procedure to all elements of a list. Returns a list as a result
;Signature: map(proc,sequence)
;Purpose: Apply ’proc’ to all ’sequence’.
;Type: [[T1 -> T2]*LIST(T1) -> LIST(T2)]
;Examples:
;(map abs (list ))
; ==> ( )
;(map (lambda (x) (* x x)) (list ))
; ==> ( )
;Post-condition: For all i=1..length(sequence): resulti = proc(sequencei)

11. Map in Java? A little better: mySequence.map((lambda (i) (sysout i)))
List<Integer> mySequence = new LinkedList<> {1,2,3,4};
mySequence.map((lambda (i)
(sysout i)))
Perfect!

12. Map Example: scale-list
Scaling list of numbers by a factor
;Signature: scale-list(items,factor)
;Purpose: Scaling elements of a number list by a factor.
;Type: [LIST(Number)*Number -> LIST(Number)]
> (scale-list (list ) 10)
( )

13. Implementation of scale-list
No Map
Map
(define scale-list (lambda (items factor) (if (null? items) (list) (cons (* (car items) factor) (scale-list (cdr items) factor)))))
(define scale-list (lambda (items factor) (map (lambda (x) (* x factor)) items))

14. Map Example: scale-tree
Mapping over hierarchical lists
>(scale-tree
(list 1
(list 2 (list 3 4) 5)
(list 6 7))
10)
(10 (20 (30 40) 50) (60 70))

15. Implementation of scale-tree
No Map
Map
(define scale-tree (lambda (tree factor) (cond ((null? tree) (list)) ((not (list? tree)) (* tree factor)) (else (cons (scale-tree (car tree) factor) (cdr tree) factor))))))
(define scale-tree (lambda (tree factor) (map (lambda (sub-tree) (if (list? sub-tree) (scale-tree sub-tree factor) (* factor))) tree)))

16. Map in Java
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7); //Old way: for(Integer n: list) { System.out.println(n); } //New way: list.forEach(n -> System.out.println(n)); //Scheme (map list (lambda(n) (display n))

17. Implementation of Map
;Signature: map(proc,items) ;Purpose: Apply ’proc’ to all ’items’. ;Type: [[T1 -> T2]*LIST(T1) -> LIST(T2)] (define map (lambda (proc items) (if (null? items) (list) (cons (proc (car items)) (map proc (cdr items))))))

18. A More General Map
So far, the procedure can get only a single parameter: an item in the list
Map in Scheme is more general: n-ary procedure and n lists (with same length)
Example:
> (map +
(list 1 2 3)
(list )
(list ))
( )

19. Haskell Curry

20. Function Currying: Reminder
Technique for turning a function with n parameters to n functions with a single parameter
Good for partial evaluation

21. Currying
;Type: [Number*Number -> Number] (define add (λ (x y) (+ x y))) ;Type: [Number -> [Number -> Number]] (define c-add (λ (x) (λ (y) (add x y)))) (define add3 (c-add 3)) (add3 4) 7

22. Why Currying? (define add-fib (lambda (x y) (+ (fib x) y)))
(define c-add-fib (lambda (x) (lambda (y) (+ (fib x) y)))) (let ((fib-x (fib x))) (+ fib-x y)))))

23. Curried Map Delayed List Naïve Version:
;Signature: c-map-proc(proc) ;Purpose: Create a delayed map for ’proc’. ;Type: [[T1 -> T2] -> [LIST(T1) -> LIST(T2)]] (define c-map-proc (lambda (proc) (lambda (lst) (if (empty? lst) lst (cons (proc (car lst)) ((c-map-proc proc) (cdr lst)))))))

24. Curried Map – delay the list
(define c-map-proc (lambda (proc) (letrec ((iter (lambda (lst) (if (empty? lst) lst (cons (proc (car lst)) (iter (cdr lst))))))) iter)))

25. Curried Map – delay the proc
;; Signature: c-map-list(lst) ;; Purpose: Create a delayed map for ’lst’. ;; Type: [LIST(T1) -> [[T1 -> T2] -> LIST(T2)]] (define c-map-list (lambda (lst) (if (empty? lst) (lambda (proc) lst) ; c-map-list returns a procedure (let ((mapped-cdr (c-map-list (cdr lst)))) ;Inductive Currying (lambda (proc) (cons (proc (car lst)) (mapped-cdr proc)))))))

26. Filter Homogenous List
Signature: filter(predicate, sequence) Purpose: return a list of all sequence elements that satisfy the predicate Type: [[T-> Boolean]*LIST(T) -> LIST(T)] Example: (filter odd? (list )) ==> (1 3 5) Post-condition: result = sequence - {el|el∈sequence and not(predicate(el))}``

27. Accumulate Procedure Application
Signature: accumulate(op,initial,sequence) Purpose: Accumulate by ’op’ all sequence elements, starting (ending) with ’initial’ Type: [[T1*T2 -> T2]*T2*LIST(T1) -> T2] Examples: (accumulate + 0 (list )) ==> 15 (accumulate * 1 (list )) ==> 120

28. Interval Enumeration
Signature: enumerate-interval(low, high) Purpose: List all integers within an interval: Type: [Number*Number -> LIST(Number)] Example: (enumerate-interval 2 7) ==> ( ) Pre-condition: high > low Post-condition: result = (low low high)

29. Enumerate Tree
Signature: enumerate-tree(tree) Purpose: List all leaves of a number tree Type: [LIST union T -> LIST(Number)] Example: (enumerate-tree (list 1 (list 2 (list 3 4)) 5)) ==> ( ) Post-condition: result = flatten(tree)

30. Sum-odd-squares
; Signature: sum-odd-squares(tree) ; Purpose: return the sum of all odd square leaves ; Type: [LIST -> Number] (define sum-odd-squares (lambda (tree) (accumulate + 0 (map square (filter odd? (enumerate-tree tree))))))

31. Even Fibonacci Numbers
Without sequence operations:
With sequence operations:
(define even-fibs (lambda (n) (letrec ((next (lambda(k) (if (> k n) (list) (let ((f (fib k))) (if (even? f) (cons f (next (+ k 1))) (next (+ k 1)))))))) (next 0))))
(define even-fibs (lambda (n) (accumulate cons (list) (filter even? (map fib (enumerate-interval 0 n))))))

32. Filter implementation
;; Signature: filter(predicate, sequence) ;; Purpose: return a list of all sequence elements that satisfy the predicate ;; Type: [[T-> Boolean]*LIST(T) -> LIST(T)] (define filter (lambda (predicate sequence) (cond ((null? sequence) sequence) ((predicate (car sequence)) (cons (car sequence) (filter predicate (cdr sequence)))) (else (filter predicate (cdr sequence))))))

33. Accumulate Implementation
;; Signature: accumulate(op,initial,sequence) ;; Purpose: Accumulate by ’op’ all sequence elements, starting (ending) ;; with ’initial’ ;; Type: [[T1*T2 -> T2]*T2*LIST(T1) -> T2] (define accumulate (lambda (op initial sequence) (if (null? sequence) initial (op (car sequence) (accumulate op initial (cdr sequence))))))

34. Enumerate-interval Implementation
;; Signature: enumerate-interval(low, high) ;; Purpose: List all integers within an interval: ;; Type: [Number*Number -> LIST(Number)] (define enumerate-interval (lambda (low high) (if (> low high) (list) (cons low (enumerate-interval (+ low 1) high)))))

35. Enumerate-Tree Implementation
;; Signature: enumerate-tree(tree) ;; Purpose: List all leaves of a number tree ;; Type: [LIST union T -> LIST(Number)] (define enumerate-tree (lambda (tree) (cond ((null? tree) (tree)) ((not (list? tree)) (list tree)) (else (append (enumerate-tree (car tree)) (enumerate-tree (cdr tree)))))))