1. 1 Data Abstraction. Pairs and Lists. (SICP Sections 2.1.1 – 2.2.1)

2. 2 Procedural abstraction Export only what is needed. Publish: name, number and type of arguments (and conditions they must satisfy) type of procedure’s return value Guarantee: the behavior of the procedure Hide: local variables and procedures, way of implementation, internal details, etc. Interface Implementation

3. 3 Data-object abstraction Export only what is needed. Publish: constructors, selectors Guarantee: the behavior Hide: local variables and procedures, way of implementation, internal details, etc. Interface Implementation

4. 4 An example: Rational numbers We would like to represent rational numbers. A rational number is a quotient a/b of two integers. Constructor: (make-rat a b) Selectors: (numer r) (denom r) Guarantee: (numer (make-rat a b)) = a (denom (make-rat a b)) = b

5. 5 An example: Rational numbers We would like to represent rational numbers. A rational number is a quotient a/b of two integers. Constructor: (make-rat a b) Selectors: (numer r) (denom r) A better Guarantee: (numer (make-rat a b)) (denom (make-rat a b)) = a b A weaker condition, but still sufficient!

6. 6 (add-rat x y) (sub-rat x y) (mul-rat x y) (div-rat x y) (equal-rat? x y) (print-rat x) We can now use the constructors and selectors to implement operations on rational numbers: A form of wishful thinking: we don’t know how make-rat numer and denom are implemented, but we use them.

7. 7 (define (equal-rat? x y) (= (* (numer x) (denom y)) (* (numer y) (denom x)))) Implementing the operations (define (mul-rat x y) (make-rat (* (numer x) (numer y)) (* (denom x) (denom y)))) (define (div-rat x y) (make-rat (* (numer x) (denom y)) (* (denom x) (numer y)))) (define (sub-rat x y) … (define (add-rat x y) ;n1/d1 + n2/d2 = (n1. d2 + n2. d1) / (d1. d2) (make-rat (+ (* (numer x) (denom y)) (* (numer y) (denom x))) (* (denom x) (denom y))))

8. 8 Using the rational package (define (print-rat x) (newline) (display (numer x)) (display ”/”) (display (denom x))) (define one-half (make-rat 1 2)) (print-rat one-half)  1/2 (define one-third (make-rat 1 3)) (print-rat (add-rat one-half one-third))  5/6 (print-rat (add-rat one-third one-third))  6/9

9. 9 Abstraction barriers Programs that use rational numbers add-rat sub-rat mul-rat… make-rat numer denom rational numbers in problem domain rational numbers as numerators and denumerators

10. 10 Gluing things together We still have to implement numer, denom, and make-rat A pair: We need a way to glue things together… (define x (cons 1 2)) (car x)  1 (cdr x)  2

11. 11 Pair: A primitive data type. Constructor: (cons a b) Selectors: (car p) (cdr p) Guarantee: (car (cons a b)) = a (cdr (cons a b)) = b Abstraction barrier: We say nothing about the representation or implementation of pairs.

12. 12 Pairs (define x (cons 1 2)) (define y (cons 3 4)) (define z (cons x y)) (car (car z))  1 ;(caar z) (car (cdr z))  3 ;(cadr z)

13. 13 Implementing make-rat, numer, denom (define (make-rat n d) (cons n d)) (define (numer x) (car x)) (define (denom x) (cdr x))

14. מבוא מורחב שיעור 7 14 Abstraction barriers Programs that use rational numbers add-rat sub-rat mul-rat... make-rat numer denom cons car cdr rational numbers in problem domain rational numbers as numerators and denumerators rational numbers as pairs

15. 15 Alternative implementation for add-rat (define (add-rat x y) (cons (+ (* (car x) (cdr y)) (* (car y) (cdr x))) (* (cdr x) (cdr y)))) Abstraction Violation If we bypass an abstraction barrier, changes to one level may affect many levels above it. Maintenance becomes more difficult.

16. 16 A solution: change the constructor (define (make-rat a b) (let ((g (gcd a b))) (cons (/ a g) (/ b g)))) In our current implementation we keep 10000/20000 as such and not as 1/2. This: Makes the computation more expensive. Prints out clumsy results. No other changes are required! Rationals - Alternative Implementation

17. 17 Reducing to lowest terms, another way (define (make-rat n d) (cons n d)) (define (numer x) (let ((g (gcd (car x) (cdr x)))) (/ (car x) g))) (define (denom x) (let ((g (gcd (car x) (cdr x)))) (/ (cdr x) g)))

18. 18 How can we implement pairs? (first solution – “lazy” implementation) (define (cons x y) (lambda (f) (f x y))) (define (car z) (z (lambda (x y) x))) (define (cdr z) (z (lambda (x y) y)))

19. 19 (define (cons x y) (lambda (f) (f x y))) ( define (car z) (z (lambda (x y) x))) (define (cdr z) (z (lambda (x y) y))) How can we implement pairs? (first solution, cont’) > (define p (cons 1 2)) Name Value (lambda(f) (f 1 2)) p > (car p) ( (lambda(f) (f 1 2)) (lambda (x y) x)) ( (lambda(x y) x) 1 2 ) > 1

20. 20 How can we implement pairs? (Second solution: “eager” implementation) (define (cons x y) (lambda (m) (cond ((= m 0) x) ((= m 1) y) (else (error "Argument not 0 or 1 -- CONS" m)))))) (define (cdr z) (z 1)) (define (car z) (z 0))

21. 21 (define (cons x y) (lambda (m) (cond ((= m 0) x) ((= m 1) y) (else...))) ( define (car z) (z 0)) (define (cdr z) (z 1)) Implementing pairs (second solution, cont’) > (define p (cons 3 4)) (lambda(m) (cond ((= m 0) 3) ((= m 1) 4) (else..))) p > (car p) ((lambda(m) (cond..)) 0) (cond ((= 0 0) 3) ((= 0 1) 4) (else...))) > 3 Name Value

22. 22 Implementation of Pairs - The way it is really done Scheme provides an implementation of pairs, so we do not need to use these “clever” implementations. The natural implementation is by using storage. The two solutions we presented show that the distinction between storage and computation is not always clear. Sometimes we can trade data for computation. The solutions we showed have their own significance: The first is used to show that lambda calculus can simulate other models of computation (theoretical importance). The second – message passing – is the basis for Object Oriented Programming. We will return to it later.

23. 23 Box and Pointer Diagram A pair can be implemented directly using two “pointers”. Originally on IBM 704: (car a) Contents of Address part of Register (cdr a) Contents of Decrement part of Register (define a (cons 1 2)) 2 1 a

24. 24 Box and pointer diagrams (cont.) 4 1 3 2 (cons (cons 1 (cons 2 3)) 4)

25. 25 Compound Data A closure property: The result obtained by creating a compound data structure can itself be treated as a primitive object and thus be input to the creation of another compound object. Pairs have the closure property: We can pair pairs, pairs of pairs etc. (cons (cons 1 2) 3) 3 2 1

26. 26 Lists (cons 1 (cons 3 (cons 2 ’() ))) 1 3 2 Syntactic sugar: (list 1 3 2) The empty list (a.k.a. null or nill)

27. מבוא מורחב שיעור 7 27 Formal Definition of a List A list is either ’() -- The empty list A pair whose cdr is a list. Lists are closed under the operations cons and cdr: If lst is a non-empty list, then (cdr lst) is a list. If lst is a list and x is arbitrary, then (cons x lst) is a list.

28. 28 Lists (list... ) is syntactic sugar for (cons (cons ( … (cons ’() )))) …

29. 29 Lists (examples) (cdr (list 1 2 3)) (cdr (cons 1 (cons 2 (cons 3 ’() )))) (cons 2 (cons 3 ’() )) (list 2 3) (cons 3 (list 1 2)) (cons 3 (cons 1 (cons 2 ’() ))) (list 3 1 2) 3 1 2 2 3 The following expressions all result in the same structure: and similarly the following

30. 30 Further List Operations (define one-to-four (list 1 2 3 4)) one-to-four ==> (1 2 3 4) (1 2 3 4) ==> error (car one-to-four) ==> (car (cdr one-to-four)) ==> 1 2 (cadr one-to-four) ==> 2 ( caddr one-to-four) ==> 3

31. 31 More Elaborate Lists (list 1 2 3 4) (cons (list 1 2) (list 3 4)) (list (list 1 2) (list 3 4)) 1 2 3 4 1 3 4 2 1 3 4 2 Prints as (1 2 3 4) Prints as ((1 2) 3 4) Prints as ((1 2) (3 4))

32. 32 Yet More Examples  p2 ( (1. 2) (1. 2) ) 1 2 p 3 p1 p2  (define p (cons 1 2))  p (1. 2)  (define p1 (cons 3 p)  p1 (3 1. 2)  (define p2 (list p p))

33. 33 The Predicate Null? null? : anytype -> boolean (null? ) #t if evaluates to empty list #f otherwise (null? 2)  #f (null? (list 1))  #f (null? (cdr (list 1)))  #t (null? ’())  #t (null? null)  #t

34. 34 The Predicate Pair? pair? : anytype -> boolean (pair? ) #t if evaluates to a pair #f otherwise. (pair? (cons 1 2))  #t (pair? (cons 1 (cons 1 2)))  #t (pair? (list 1))  #t (pair? ’())  #f (pair? 3)  #f (pair? pair?)  #f

35. 35 The Predicate Atom? atom? : anytype -> boolean (define (atom? z) (and (not (pair? z)) (not (null? z)))) (define (square x) (* x x)) (atom? square)  #t (atom? 3)  #t (atom? (cons 1 2))  #f

36. 36 More examples  (define digits (list 1 2 3 4 5 6 7 8 9)) ? (0 1 2 3 4 5 6 7 8 9)  (define digits1 (cons 0 digits))  digits1  (define l (list 0 digits))  l ? (0 (1 2 3 4 5 6 7 8 9))

37. 37 The procedure length  (define digits (list 1 2 3 4 5 6 7 8 9))  (length digits) 9  (define l null)  (length l) 0  (define l (cons 1 l))  (length l) 1 (define (length l) (if (null? l) 0 (+ 1 (length (cdr l)))))

38. The procedure append (define (append list1 list2) (cond ((null? list1) list2) ; base (else (cons (car list1) ; recursion (append (cdr list1) list2))))) 38

39. Constructor Type: Number * T -> LIST(T) > (make-list 7 ’foo) (foo foo foo foo foo foo foo) > (make-list 5 1) (1 1 1 1 1) 39

40. List type Pairs: For every type assignment TA and type expressions S,S1,S2: TA |- cons:[S1*S2 -> PAIR(S1,S2)] TA |- car:[PAIR(S1,S2) -> S1] TA |- cdr:[PAIR(S1,S2) -> S2] TA |- pair?:[S -> Boolean] TA |- equal?:[PAIR(S1,S2)*PAIR(S1,S2) -> Boolean] 40

41. For every type environment TA and type expression S: TA |- list:[Unit -> LIST(S)] TA |- cons:[T*LIST(S) -> LIST(S)] TA |- car:[LIST(S) -> S] TA |- cdr:[LIST(S) -> LIST(S)] TA |- null?:[LIST(S) -> Boolean] TA |- list?:[S -> Boolean] TA |- equal?:[LIST(S)*LIST(S) -> Boolean] 41

42. Cont. For every type environment TA and type expression S: TA |- list:[Unit -> LIST] TA |- cons:[S*LIST -> LIST] TA |- car:[LIST -> S] TA |- cdr:[LIST -> LIST] TA |- null?:[LIST -> Boolean] TA |- list?:[S -> Boolean] TA |- equal?:[LIST*LIST -> Boolean] 42