This presentation is the property of its rightful owner.
1 / 31

# David Evans http://www.cs.virginia.edu/~evans PowerPoint PPT Presentation

Lecture 8: Cons car cdr sdr wdr. David Evans http://www.cs.virginia.edu/~evans. CS200: Computer Science University of Virginia Computer Science. Menu. History of Scheme LISP Lists List Recursion. Confusion Is Good! It means you are learning new ways of thinking.

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

#### Presentation Transcript

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

### Confusion Is Good!It means you are learning new ways of thinking.

CS 200 Spring 2003

### History of Scheme

• 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

### LISP

“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

### Making Lists

CS 200 Spring 2003

### Making a Pair

> (cons 1 2)

(1 . 2)

1

2

consconstructs a pair

CS 200 Spring 2003

### Splitting a Pair

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

### Why “car” and “cdr”?

• 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

### Implementing cons, car and cdr

• 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

### Pairs are fine, but how do we make threesomes?

CS 200 Spring 2003

### Threesome?

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

### Triple

• 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

### Multuples

• 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

### Lists

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

### Recursive Transition Networks

ORNATE NOUN

end

begin

NOUN

ARTICLE

ORNATE NOUN ::= ARTICLE ADJECTIVE NOUN

CS 200 Spring 2003

### Recursive Transition Networks

ORNATE NOUN

end

begin

NOUN

ARTICLE

ORNATE NOUN ::= ARTICLE ADJECTIVES NOUN

CS 200 Spring 2003

### Lists

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

### Null

List ::= (consElementList)

List ::=

null

A list is either:

a pair where the second part is a list

or, empty (null)

CS 200 Spring 2003

### List Examples

> null

()

> (cons 1 null)

(1)

> (list? null)

#t

> (list? (cons 1 2))

#f

> (list? (cons 1 null))

#t

CS 200 Spring 2003

### More List Examples

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

### List Recursion

CS 200 Spring 2003

### Defining Recursive Procedures

• 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

### Defining Recursive Procedures

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

### Defining Sumlist

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

### Defining Productlist

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

### Defining Length

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

### Defining insertl

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

### Definitions

(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

### Charge

• 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