David evans http www cs virginia edu evans
This presentation is the property of its rightful owner.
Sponsored Links
1 / 31

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


  • 172 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

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

An Image/Link below is provided (as is) to download presentation

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


David evans http www cs virginia edu evans

Lecture 8: Cons

car

cdr

sdr

wdr

David Evans

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

CS200: Computer Science

University of Virginia

Computer Science


David evans cs virginia

Menu

  • History of Scheme

    • LISP

  • Lists

  • List Recursion

CS 200 Spring 2003


Confusion is good it means you are learning new ways of thinking

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

CS 200 Spring 2003


History of scheme

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


David evans cs virginia

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

Making Lists

CS 200 Spring 2003


Making a pair

Making a Pair

> (cons 1 2)

(1 . 2)

1

2

consconstructs a pair

CS 200 Spring 2003


Splitting a pair

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

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

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

Pairs are fine, but how do we make threesomes?

CS 200 Spring 2003


Threesome

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

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


Quadruple

Quadruple

  • 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

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

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


Recursive transition networks

From Lecture 6

Recursive Transition Networks

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


Recursive transition networks1

Recursive Transition Networks

ORNATE NOUN

end

begin

NOUN

ARTICLE

ADJECTIVE

ORNATE NOUN ::= ARTICLE ADJECTIVES NOUN

ADJECTIVES ::= ADJECTIVE ADJECTIVES

ADJECTIVES ::=

CS 200 Spring 2003


Lists1

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


David evans cs virginia

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

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

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

List Recursion

CS 200 Spring 2003


Defining recursive procedures

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 procedures1

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

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

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

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

Defining insertl

(define insertl

(lambda (lst f stopval)

(if (null? lst)

stopval

(f (car lst)

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

CS 200 Spring 2003


Definitions

(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

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


  • Login