lecture 16: tables and oop

1

Lecture 16: Tables and OOP

2

Tables -- get and put

3

One dimentional tables

*table*

c dba 1 2 3 4

(define (lookup key table) (let ((record (assoc key (cdr table)))) (if record (cdr record) false)))

4


(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


(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


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

c dba 1 2 3 4e 5

7


(define (make-table)(list '*table*))

*table*

8

Two dimentional tables

presidents

ClintonBush 88 92

elections

NYFlorida GoreBush Bush

California

*table*

9


(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


(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


presidents

ClintonBush 88 92

elections


California

*table*

Gore

12


Example:

(insert! ‘singers ‘Madona ‘M table)

==> ok

13


ClintonBush 88 92

presidents

*table*

elections


CaliforniaGore

singers

Madona M

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

Introduction to Object Oriented Programming

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

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

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

Example: What is our "pair" object?

(define foo (cons 1 2))

GE

p: x ybody: ( (msg) (cond ..))

cons:

1

p: msgbody: (cond ...)

E1

foo:

x: 1y: 2

1(car foo) | GE=> (foo 'CAR) | E2=>

2

(cond ...) | E3=> x | E3=> 1

msg: CARE3

3

2 3(car foo) becomes (foo 'CAR)

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

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: msgbody: (cond ...)

E4

bar:

x: 3y: 4

1

p: new-carbody: (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)

6changes x value to 0 in E4

0

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

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

Programming Styles – Procedural vs. Object-Oriented

• Procedural programming:• Organize system around procedures that operate on data

(do-something <data> <arg> ...)

(do-another-thing <data>)

•Object-based programming:•Organize system around objects that receive messages (<object> 'do-something <arg>) (<object> 'do-another-thing)•An object encapsulates data and operations•Message passing and procedure are the means to write Object•Oriented code in scheme

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

Table in OO style

(define operation-table (make-table))(define get (operation-table 'lookup-proc))(define put (operation-table 'insert-proc!))

28

(define oper-table (make-table)) | GE

GE

p: b:(let ((local-table (list '*table*))) . . . )

make-table:

lookup:p: key-1 key-2b: . . .

insert!:

oper-table:

dispatch:

E1 local-table

*table*

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

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

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

Queues in OO style

A lazy approach:

We know how to do stacks so lets do queues with stacks :)

We need two stacks:

stack1stack2

insertdelete

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

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

Queues in OO style

Inheritance: One class is a refinement of another

The queue class is a subclass of the stack class

lecture 16: tables and oop

Documents