1. 6.001 SICP Data abstractions
Abstractions and their variations
Basic data abstractions
Why data abstractions are useful
6.001 SICP

2. Procedural abstraction
Process of procedural abstraction
Define formal parameters, capture process in body of procedure
Give procedure a name
Hide implementation details from user, who just invokes name to apply procedure
procedure
Output: type
Input: type
Details of contract for converting input to output
6.001 SICP

3. Procedural abstraction example: sqrt
To find an approximation of square root of x:
Make a guess G
Improve the guess by averaging G and x/g
Keep improving the guess until it is good enough
(define try (lambda (guess x)
(if (good-enuf? guess x)
guess
(try (improve guess x) x))))
(define improve (lambda (guess x)
(average guess (/ x guess))))
(define average (lambda (a b) (/ (+ a b) 2)))
(define good-enuf? (lambda (guess x)
(< (abs (- (square guess) x)) 0.001)))
(define sqrt (lambda (x) (try 1 x)))
6.001 SICP

4. The universe of procedures for sqrt
average
try
improve
Good-enuf?
sqrt
6.001 SICP

5. The universe of procedures for sqrt
average
try
improve
Good-enuf?
sqrt
6.001 SICP

6. sqrt - Block Structure (define (sqrt x) (define (good-enuf? guess)
(< (abs (- (square guess) x))
0.001))
(define (improve guess)
(average guess (/ x guess)))
(define (sqrt-iter guess)
(if (good-enuf? guess)
guess
(sqrt-iter (improve guess))))
(sqrt-iter 1.0))
good-enuf?
improve
sqrt
x: number
: number
6.001 SICP

7. Clean version of sqrt  easy to add cbrt
(define (sqrt x)
(fixed-point
(average-damp
(lambda (y) (/ x y)))
1))
Compare this to Heron’s algorithm from before – same process, but ideas intertwined with code
(define (cbrt x)
(lambda (y) (/ x (square y))))
6.001 SICP

8. Summary of part 1 Procedural abstractions
Isolate details of process from its use
Designer has choice of which ideas to isolate, in order to support general patterns of computation
Good planning in how to collect procedures within higher order structures can make it easier to add new computations
6.001 SICP

9. Language Elements Primitives prim. data: numbers, strings, booleans
primitive procedures
Means of Combination
procedure application
compound data (today)
Means of Abstraction
naming
compound procedures
block structure
higher order procedures (more today)
conventional interfaces – lists (today)
data abstraction (next lecture)
6.001 SICP

10. Compound data
Need a way of gluing data elements together into a unit that can be treated as a simple data element
Need ways of getting the pieces back out
Need a contract between the “glue” and the “unglue”
Ideally want the result of this “gluing” to have the property of closure:
“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”
6.001 SICP

11. Pairs (cons cells)
(cons <x-exp> <y-exp>) ==> <P> ;type: x, x  Pair
Where <x-exp> evaluates to a value <x-val>, and <y-exp> evaluates to a value <y-val>
Returns a pair <P> whose car-part is <x-val> and whose cdr-part is <y-val>
(car <P>) ==> <x-val> ;type: Pairtype of car part
Returns the car-part of the pair <P>
(cdr <P>) ==> <y-val> ;type: Pairtype of cdr part
Returns the cdr-part of the pair <P>
6.001 SICP

12. Compound Data Treat a PAIR as a single unit:
Can pass a pair as argument
Can return a pair as a value
(define (make-point x y)
(cons x y))
(define (point-x point)
(car point))
(define (point-y point)
(cdr point))
(define (make-seg pt1 pt2)
(cons pt1 pt2))
(define (start-point seg)
(car seg)) 5 4 3 2 1
(2, 3)
point
6.001 SICP

13. Pair Abstraction Constructor ; cons: A,B -> A X B
; cons: A,B -> Pair<A,B> (cons <x> <y>) ==> <P>
Accessors
; car: Pair<A,B> -> A (car <P>) ==> <x>
; cdr: Pair<A,B> -> B (cdr <P>) ==> <y>
Predicate
; pair? anytype -> boolean (pair? <z>) ==> #t if <z> evaluates to a pair, else #f
6.001 SICP

14. Pair abstraction
Note how there exists a contract between the constructor and the selectors:
(car (cons <a> <b> ))  <a>
(cdr (cons <a> <b> ))  <b>
Note how pairs have the property of closure – we can use the result of a pair as an element of a new pair:
(cons (cons 1 2) 3)
6.001 SICP

15. Conventional interfaces -- lists
A list is a data object that can hold an arbitrary number of ordered items.
More formally, a list is a sequence of pairs with the following properties:
Car-part of a pair in sequence – holds an item
Cdr-part of a pair in sequence – holds a pointer to rest of list
Empty-list nil – signals no more pairs, or end of list
Note that lists are closed under operations of cons and cdr.
6.001 SICP

16. Conventional Interfaces - Lists
(cons <el1> <el2>)
(list <el1> <el2> ... <eln>)
Predicate ; null? anytype -> boolean (null? <z>) ==> #t if <z> evaluates to empty list
<el1>
<el2>
<el1>
<el2>
<eln> …
6.001 SICP

17. … to be really careful
For today we are going to create different constructors and selectors for a list
(define first car)
(define rest cdr)
(define adjoin cons)
Note how these abstractions inherit closure from the underlying abstractions!
6.001 SICP

18. Common Pattern #1: cons’ing up a list
(define (enumerate-interval from to)
(if (> from to)
nil
(adjoin from
(enumerate-interval
(+ 1 from)
to))))
(e-i 2 4)
(if (> 2 4) nil (adjoin 2 (e-i (+ 1 2) 4)))
(if #f nil (adjoin 2 (e-i 3 4)))
(adjoin 2 (e-i 3 4))
(adjoin 2 (adjoin 3 (e-i 4 4)))
(adjoin 2 (adjoin 3 (adjoin 4 (e-i 5 4))))
(adjoin 2 (adjoin 3 (adjoin 4 nil)))
(adjoin 2 (adjoin ))
(adjoin )
==> (2 3 4) 4 3 4 2 3 4
6.001 SICP

19. Common Pattern #2: cdr’ing down a list
(define (list-ref lst n)
(if (= n 0)
(first lst)
(list-ref (rest lst)
(- n 1))))
(define (length lst)
(if (null? lst)
(+ 1 (length (rest lst)))))
joe
(list-ref joe 1) 2 3 4
6.001 SICP

20. Cdr’ing and Cons’ing Examples
(define (copy lst)
(if (null? lst)
nil ; base case
(adjoin (first lst) ; recursion
(copy (rest lst)))))
(append (list 1 2) (list 3 4))
==> ( )
Strategy: “copy” list1 onto front of list2.
(define (append list1 list2)
(cond ((null? list1) list2) ; base
(else
(adjoin (first list1) ; recursion
(append (rest list1)
list2)))))
6.001 SICP

21. Common Pattern #3: Transforming a List
(define (square-list lst)
(if (null? lst)
nil
(adjoin (square (first lst))
(square-list (rest lst)))))
(define (double-list lst)
(adjoin (* 2 (first lst))
(double-list (rest lst)))))
(define (map proc lst)
(adjoin (proc (first lst))
(map proc (rest lst)))))
(map square lst))
(map (lambda (x) (* 2 x)) lst))
6.001 SICP

22. Common Pattern #4: Filtering a List
(define (filter pred lst)
(cond ((null? lst) nil)
((pred (first lst))
(adjoin (first lst)
(filter pred (rest lst))))
(else (filter pred (rest lst)))))
6.001 SICP

23. Common Pattern #5: Accumulating Results
(define (add-up lst)
(if (null? lst)
(+ (first lst)
(add-up (rest lst)))))
(define (mult-all lst) 1
(* (first lst)
(mult-all (rest lst)))))
(define (accumulate op init lst)
init
(op (first lst)
(accumulate op init (rest lst)))))
(accumulate + 0 lst))
6.001 SICP

24. Your Turn (define (length lst) (if (null? lst)
(+ 1 (length (rest lst)))))
(define (accumulate op init lst)
init
(op (first lst)
(accumulate op init (rest lst)))))
Rewrite length as an accumulation
(define (length lst)
(accumulate (lambda (item) 1)
lst))
6.001 SICP

25. Example of using structures and interfaces
(define make-point cons)
(define point-x car)
(define point-y cdr)
Assume that a polygon is an ordered list of points
To find the center of figure
(define (centroid pts)
(let ((total (length pts)))
(make-point
(/ (accumulate + 0
(map point-x pts))
total)
(map point-y pts))
total))))
6.001 SICP

26. Example of using structures and interfaces
Assume that a polygon is an ordered list of points
To shift a figure
(define (shift pt offset)
(make-point (- (point-x pt)
(point-x offset))
(- (point-y pt)
(point-y offset))))
(define (shift-figure pts offset)
(map (lambda (pt)
(shift pt offset))
pts))
6.001 SICP

27. Example of using structures and interfaces
Assume that a polygon is an ordered list of points
To rotate about the center
(define (rotate pt)
(make-point
(- (point-y pt))
(point-x pt)))
(define (rotate-figure pts)
(let ((center (centroid pts)))
(shift-figure
(map rotate
(shift-figure pts center))
(- (point-x center))
(- (point-y center))))))
6.001 SICP

28. Example of using structures and interfaces
Assume that a polygon is an ordered list of points
To shift and clip
(define (shift&clip pts offset)
(filter (lambda (pt)
(>= (point-x pt) 0))
(map (lambda (pt)
(shift pt offset))
pts)))
6.001 SICP

29. Summary of part 2
Data structures are built on contract of constructors and accessors
Data structures have associated procedures for manipulation – typically the recursive structure of the procedure mimics the recursive structure of the data object
Building data structures
Think about good organization for data
Think about how procedures to manipulate structure will mimic organization of data
Build and hide details of abstraction from use of abstraction, by relying on contract
6.001 SICP