1. מבוא מורחב שיעור 7 1 Lecture 7 Data Abstraction. Pairs and Lists. (Sections 2.1.1 – 2.2.1)

2. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 18 How can we implement pairs? (first solution) (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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 20 How can we implement pairs? (Second solution: message passing) (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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 24 Box and pointer diagrams (cont.) 4 1 3 2 (cons (cons 1 (cons 2 3)) 4)

25. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 28 Lists (list... ) is syntactic sugar for (cons (cons ( … (cons ’() )))) …

29. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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. מבוא מורחב שיעור 7 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)))))