lecture 7

7מבוא מורחב שיעור 1

Lecture 7

Data Abstraction.

Pairs and Lists.

(Sections 2.1.1 – 2.2.1)


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


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


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


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 betterGuarantee:

(numer (make-rat a b))

(denom (make-rat a b))= a

b

A weaker condition, but still sufficient!


(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.


(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))))


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


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


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


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.


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)


Implementing make-rat, numer, denom

(define (make-rat n d) (cons n d))

(define (numer x) (car x))

(define (denom x) (cdr x))


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


Alternative implementation for add-rat

(define (add-rat x y) (cons (+ (* (car x) (cdr y)) (* (car y) (cdr x))) (* (cdr x) (cdr y))))

AbstractionViolation

If we bypass an abstraction barrier,changes to one level may affect many levels above it.Maintenance becomes more difficult.


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/20000as such and not as 1/2.

This: • Makes the computation more expensive.• Prints out clumsy results.

No other changes are required!

Rationals - Alternative Implementation


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)))


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)))


(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


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))


(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


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.


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


Box and pointer diagrams (cont.)

4

1

3

2

(cons (cons 1 (cons 2 3)) 4)


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


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)


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.


Lists

(list <x1> <x2> ... <xn>)

is syntactic sugar for

(cons <x1> (cons <x2> ( … (cons <xn> ’() ))))

<x1> <x2> <xn>

…


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


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 42

Prints as (1 2 3 4)

Prints as ((1 2) 3 4)

Prints as ((1 2) (3 4))


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))


The Predicate Null?

null? : anytype -> boolean

(null? <z>) #t if <z> evaluates to empty list

#f otherwise

(null? 2) #f

(null? (list 1)) #f

(null? (cdr (list 1))) #t

(null? ’()) #t

(null? null) #t


The Predicate Pair?

pair? : anytype -> boolean

(pair? <z>) #t if <z> 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


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


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))


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)))))

lecture 7

Documents

x y printrat x

rat numer

rat x y cons

denom x cdr x

denom x numer

subrat x y

numer x numer y

numer x denom y