- 176 Views
- Uploaded on
- Presentation posted in: General

David Evans http://www.cs.virginia.edu/~evans

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Lecture 8: Cons

car

cdr

sdr

wdr

David Evans

http://www.cs.virginia.edu/~evans

CS200: Computer Science

University of Virginia

Computer Science

- History of Scheme
- LISP

- Lists
- List Recursion

CS 200 Spring 2003

CS 200 Spring 2003

- Scheme [1975]
- Guy Steele and Gerry Sussman
- Originally “Schemer”
- “Conniver” [1973] and “Planner” [1967]

- Based on LISP
- John McCarthy (late 1950s)

- Based on Lambda Calculus
- Alonzo Church (1930s)
- Last few lectures in course

CS 200 Spring 2003

“Lots of Insipid Silly Parentheses”

“LISt Processing language”

Lists are pretty important – hard to write a useful Scheme program without them.

CS 200 Spring 2003

CS 200 Spring 2003

> (cons 1 2)

(1 . 2)

1

2

consconstructs a pair

CS 200 Spring 2003

cons

> (car (cons 1 2))

1

> (cdr (cons 1 2))

2

1

2

car

cdr

car extracts first part of a pair

cdr extracts second part of a pair

CS 200 Spring 2003

- Original (1950s) LISP on IBM 704
- Stored cons pairs in memory registers
- car = “Contents of the Address part of the Register”
- cdr = “Contents of the Decrement part of the Register” (“could-er”)

- Doesn’t matters unless you have an IBM 704
- Think of them as first and rest
(define first car)

(define rest cdr)

CS 200 Spring 2003

- Using PS2:
(define cons make-point)

(define car x-of-point)

(define cdr y-of-point)

- As we implemented make-point, etc.:
(define (cons a b) (lambda (w) (if (w) a b)))

(define (car pair) (pair #t)

(define (cdr pair) (pair #f)

CS 200 Spring 2003

CS 200 Spring 2003

- (define (threesome a b c)
- (lambda (w)
- (if (= w 0) a (if (= w 1) b c))))
- (define (first t) (t 0))
- (define (second t) (t 1))
- (define (third t) (t 2))

Is there a better way of thinking about our triple?

CS 200 Spring 2003

- A triple is just a pair where one of the parts is a pair!
(define (triple a b c)

(cons a (cons b c)))

(define (t-first t) (car t))

(define (t-second t) (car (cdr t)))

(define (t-third t) (cdr (cdr t)))

CS 200 Spring 2003

- A quadruple is a pair where the second part is a triple
(define (quadruple a b c d)

(cons a (triple b c d)))

(define (q-first q) (car q))

(define (q-second q) (t-first (cdr t)))

(define (q-third t) (t-second (cdr t)))

(define (q-fourth t) (t-third (cdr t)))

CS 200 Spring 2003

- A quintuple is a pair where the second part is a quadruple
- A sextuple is a pair where the second part is a quintuple
- A septuple is a pair where the second part is a sextuple
- An octuple is group of octupi
- A list (any length tuple) is a pair where the second part is a …?

CS 200 Spring 2003

List ::= (consElementList)

A list is a pair where the second part is a list.

One little problem: how do we stop?

This only allows infinitely long lists!

CS 200 Spring 2003

From Lecture 6

ORNATE NOUN

end

begin

NOUN

ARTICLE

ADJECTIVE

ORNATE NOUN ::= ARTICLE ADJECTIVE NOUN

ORNATE NOUN ::= ARTICLE ADJECTIVE ADJECTIVE NOUN

ORNATE NOUN ::= ARTICLE ADJECTIVE ADJECTIVE ADJECTIVE NOUN

ORNATE NOUN ::= ARTICLE ADJECTIVE ADJECTIVE ADJECTIVE ADJECTIVE NOUN

ORNATE NOUN ::= ARTICLE ADJECTIVE ADJECTIVE ADJECTIVE ADJECTIVE ADJECTIVE NOUN

CS 200 Spring 2003

ORNATE NOUN

end

begin

NOUN

ARTICLE

ADJECTIVE

ORNATE NOUN ::= ARTICLE ADJECTIVES NOUN

ADJECTIVES ::= ADJECTIVE ADJECTIVES

ADJECTIVES ::=

CS 200 Spring 2003

List ::= (consElementList)

List ::=

It’s hard to write this!

A list is either:

a pair where the second part is a list

or, empty

CS 200 Spring 2003

List ::= (consElementList)

List ::=

null

A list is either:

a pair where the second part is a list

or, empty (null)

CS 200 Spring 2003

> null

()

> (cons 1 null)

(1)

> (list? null)

#t

> (list? (cons 1 2))

#f

> (list? (cons 1 null))

#t

CS 200 Spring 2003

> (list? (cons 1 (cons 2 null)))

#t

> (car (cons 1 (cons 2 null)))

1

> (cdr (cons 1 (cons 2 null)))

(2)

CS 200 Spring 2003

CS 200 Spring 2003

- Be optimistic.
- Assume you can solve it.
- If you could, how would you solve a bigger problem.

- Think of the simplest version of the problem, something you can already solve. (This is the base case.)
- Combine them to solve the problem.

CS 200 Spring 2003

on Lists

Be very optimistic

- Be optimistic.
- Assume you can solve it.
- If you could, how would you solve a bigger problem.

- Think of the simplest version of the problem, something you can already solve.
- Combine them to solve the problem.

For lists, assume we can solve

it for the cdr

For lists, the simplest version is

usually null (the zero-length list)

Combine something on the car of the list with

the recursive evaluation on the cdr. Remember

to test null? before using car or cdr.

CS 200 Spring 2003

> (sumlist (list 1 2 3 4))

10

> (sumlist null)

0

(define sumlist

(lambda (lst)

(if (null? lst)

( (car lst) (sumlist (cdr lst))

0

+

CS 200 Spring 2003

> (productlist (list 1 2 3 4))

24

> (productlist null)

1

(define productlist

(lambda (lst)

(if (null? lst)

( (car lst) (sumlist (cdr lst))

1

*

CS 200 Spring 2003

> (length (list 1 2 3 4))

4

> (length null)

0

(define length

(lambda (lst)

(if (null? lst)

( (car lst) (length (cdr lst))

0

+

1

CS 200 Spring 2003

(define insertl

(lambda (lst f stopval)

(if (null? lst)

stopval

(f (car lst)

(insertl (cdr lst) f stopval)))))

CS 200 Spring 2003

(define insertl

(lambda (lst f stopval)

(if (null? lst)

stopval

(f (car lst)

(insertl (cdr lst) f stopval)))))

(define (sumlist lst)

(insertl lst + 0))

(define (productlist lst)

(insertl lst * 1))

(define (length lst)

(insertl lst

(lambda (head rest) (+ 1 rest))

0))

CS 200 Spring 2003

- Next Time: lots more things you can do with lists (including the peg board puzzle!)
- PS3 Out Today
- Use lists to make fractals
- You have seen everything you need for it after today
- Due next week Wednesday

CS 200 Spring 2003