1. 1 Lecture 16: Tables and OOP

2. 2 Tables -- get and put

3. 3 One dimentional tables *table* cdba 12 34 (define (lookup key table) (let ((record (assoc key (cdr table)))) (if record (cdr record) false)))

4. 4 One dimentional tables (define (lookup key table) (let ((record (assoc key (cdr table)))) (if record (cdr record) false))) (define (assoc key records) (cond ((null? records) false) ((equal? key (caar records)) (car records)) (else (assoc key (cdr records)))))

5. 5 One dimentional tables (define (insert! key value table) (let ((record (assoc key (cdr table)))) (if record (set-cdr! record value) (set-cdr! table (cons (cons key value) (cdr table))))) 'ok) Example: (insert! e 5 table)

6. 6 One dimentional tables (define (insert! key value table) (let ((record (assoc key (cdr table)))) (if record (set-cdr! record value) (set-cdr! table (cons (cons key value) (cdr table))))) 'ok) *table* cdba 12 34 e 5

7. 7 One dimentional tables (define (make-table)(list '*table*)) *table*

8. 8 Two dimentional tables presidents Clinton Bush 8892 elections NY Florida Gore Bush California *table*

9. 9 Two dimentional tables (define (lookup key-1 key-2 table) (let ((subtable (assoc key-1 (cdr table)))) (if subtable (let ((record (assoc key-2 (cdr subtable)))) (if record (cdr record) false)) false))) Example: (lookup elections Florida table) ==> Bush

10. 10 Two dimentional tables (define (insert! key-1 key-2 value table) (let ((subtable (assoc key-1 (cdr table)))) (if subtable (let ((record (assoc key-2 (cdr subtable)))) (if record (set-cdr! record value) (set-cdr! subtable (cons (cons key-2 value) (cdr subtable))))) (set-cdr! table (cons (list key-1 (cons key-2 value)) (cdr table))))) 'ok) Example: (insert! elections California Gore table) ==> okbb

11. 11 Two dimentional tables presidents Clinton Bush 8892 elections NY Florida Gore Bush California *table* Gore

12. 12 Two dimentional tables Example: (insert! singers Madona M table) ==> ok

13. 13 Two dimentional tables Clinton Bush 8892 presidents *table* elections NY Florida Gore Bush California Gore singers Madona M

14. 14 Implement get and put (define oper-table (make-table)) (define (put x y v) (insert! x y v oper-table)) (define (get x y) (lookup x y oper-table))

15. 15 Introduction to Object Oriented Programming

16. 16 One View of Data Tagged data: Some complex structure constructed from cons cells Explicit tags to keep track of data types Implement a data abstraction as set of procedures that operate on the data "Generic" operations by looking at types: (define (real-part z) (cond ((rectangular? z) (real-part-rectangular (contents z))) ((polar? z) (real-part-polar (contents z))) (else (error "Unknown type -- REAL-PART" z))))

17. 17 An Alternative View of Data: Procedures with State A procedure has parameters and body as specified by expression environment (which can hold name-value bindings!) Can use procedure to encapsulate (and hide) data, and provide controlled access to that data constructor, accessors, mutators, predicates, operations mutation: changes in the private state of the procedure

18. 18 Example: Pair as a Procedure with State (define (cons x y) (lambda (msg) (cond ((eq? msg CAR) x) ((eq? msg CDR) y) ((eq? msg PAIR?) #t) (else (error "pair cannot" msg))))) (define (car p) (p CAR)) (define (cdr p) (p CDR)) (define (pair? p) (and (procedure? p) (p PAIR?)))

19. 19 Example: What is our "pair" object? (define foo (cons 1 2)) GE p: x y body: ( (msg) (cond..)) cons: 1 p: msg body: (cond...) E1 foo: x: 1 y: 2 1 (car foo) | GE => (foo 'CAR) | E2 => 2 (cond...) | E3 => x | E3 => 1 msg: CAR E3 3 2 3 (car foo) becomes (foo 'CAR)

20. 20 Pair Mutation as Change in State (define (cons x y) (lambda (msg) (cond ((eq? msg CAR) x) ((eq? msg CDR) y) ((eq? msg PAIR?) #t) ((eq? msg SET-CAR!) (lambda (new-car) (set! x new-car))) ((eq? msg SET-CDR!) (lambda (new-cdr) (set! y new-cdr))) (else (error "pair cannot" msg))))) (define (set-car! p new-car) ((p SET-CAR!) new-car)) (define (set-cdr! p new-cdr) ((p SET-CDR!) new-cdr))

21. 21 Example: Mutating a pair object (define bar (cons 3 4)) GE (cond...) | E6 => ( (new-car) (set! x new-car)) | E6 msg: SET-CAR! E6 3 1 p: msg body: (cond...) E4 bar: x: 3 y: 4 1 p: new-car body: (set! x new-car) 4 (set! x new-car) | E7 new-car: 0 E7 5 (set-car! bar 0) | GE => ((bar 'SET-CAR!) 0) | E5 2 (set-car! bar 0) 6 changes x value to 0 in E4 0

22. 22 Message Passing Style - Refinements lexical scoping for private state and private procedures (define (cons x y) (define (change-car new-car) (set! x new-car)) (define (change-cdr new-cdr) (set! y new-cdr)) (lambda (msg. args) (cond ((eq? msg CAR) x) ((eq? msg CDR) y) ((eq? msg PAIR?) #t) ((eq? msg SET-CAR!) (change-car (car args))) ((eq? msg SET-CDR!) (change-cdr (car args))) (else (error "pair cannot" msg))))) (define (car p) (p 'CAR)) (define (set-car! p val) (p 'SET-CAR! val))

23. 23 Variable number of arguments A scheme mechanism to be aware of: Desire: (add 1 2) (add 1 2 3 4) How do this? (define (add x y. rest)...) (add 1 2) => x bound to 1 y bound to 2 rest bound to '() (add 1) => error; requires 2 or more args (add 1 2 3) => rest bound to (3) (add 1 2 3 4 5) => rest bound to (3 4 5)

24. 24 Message Passing Style - Refinements lexical scoping for private state and private procedures (define (cons x y) (define (change-car new-car) (set! x new-car)) (define (change-cdr new-cdr) (set! y new-cdr)) (lambda (msg. args) (cond ((eq? msg CAR) x) ((eq? msg CDR) y) ((eq? msg PAIR?) #t) ((eq? msg SET-CAR!) (change-car (car args))) ((eq? msg SET-CDR!) (change-cdr (car args))) (else (error "pair cannot" msg))))) (define (car p) (p 'CAR)) (define (set-car! p val) (p 'SET-CAR! val))

25. 25 Programming Styles – Procedural vs. Object-Oriented Procedural programming: Organize system around procedures that operate on data (do-something...) (do-another-thing ) Object-based programming: Organize system around objects that receive messages ( 'do-something ) ( 'do-another-thing) An object encapsulates data and operations Message passing and procedure are the means to write Object Oriented code in scheme

26. 26 Tables in OO style (define (make-table) (let ((local-table (list '*table*))) (define (lookup key-1 key-2)... ) (define (insert! key-1 key-2 value)... 'ok) (define (dispatch m) (cond ((eq? m 'lookup-proc) lookup) ((eq? m 'insert-proc!) insert!) (else (error "Unknown operation -- TABLE" m)))) dispatch))

27. 27 Table in OO style (define operation-table (make-table)) (define get (operation-table 'lookup-proc)) (define put (operation-table 'insert-proc!))

28. 28 (define oper-table (make-table)) | GE GE p: b : (let ((local-table (list '*table*)))... ) make-table: lookup: p: key-1 key-2 b:... insert!: oper-table: dispatch: E1 local-table *table*

29. 29 Object-Oriented Programming Terminology Class: specifies the common behavior of entities in scheme, a "maker" procedure E.g. cons or make-table in our previous examples Instance: A particular object or entity of a given class in scheme, an instance is a message-handling procedure made by the maker procedure E.g. foo or bar or oper-table in our previous examples

30. 30 Stacks in OO style (define (make-stack) (let ((top-ptr '())) (define (empty?) (null? top-ptr)) (define (delete!) (if (null? top-ptr) (error...) (set! top-ptr (cdr top-ptr))) top-ptr ) (define (insert! elmt) (set! top-ptr (cons elmt top-ptr)) top-ptr) (define (top) (if (null? top-ptr) (error...) (car top-ptr))) (define (dispatch op) (cond ((eq? op 'empty?) empty?) ((eq? op 'top) top) ((eq? op 'insert!) insert!) ((eq? op 'delete!) delete!))) dispatch))

31. 31 Stacks in OO style (define s (make-stack)) ==> ((s 'insert!) 'a) ==> ((s 'insert!) 'b) ==> ((s 'top)) ==> ((s 'delete!)) ==> ((s 'top)) ==> ((s 'delete!)) ==> undef (a) (b a) b (a) a ()()

32. 32 Queues in OO style A lazy approach: We know how to do stacks so lets do queues with stacks :) We need two stacks: stack1 stack2 insert delete

33. 33 Queues in OO style ((q insert) a) a ((q insert) b) a b ((q delete)) a b b ((q insert) c) b c c ((q delete))

34. 34 Queues in OO style (define (make-queue) (let ((stack1 (make-stack)) (stack2 (make-stack))) (define (reverse-stack s1 s2) _______________) (define (empty?) (and ((stack1 'empty?)) ((stack2 'empty?)))) (define (delete!) (if ((stack2 'empty?)) (reverse-stack stack1 stack2)) (if ((stack2 'empty?)) (error...) ((stack2 'delete!)))) (define (first) (if ((stack2 'empty?)) (reverse-stack stack1 stack2)) (if ((stack2 'empty?)) (error...) ((stack2 'top)))) (define (dispatch op) (cond ((eq? op 'empty?) empty?) ((eq? op 'first) first) ((eq? op 'delete!) delete!) (else (stack1 op)))) dispatch))

35. 35 Queues in OO style Inheritance: One class is a refinement of another The queue class is a subclass of the stack class