david evans http www cs virginia edu evans n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
David Evans cs.virginia/~evans PowerPoint Presentation
Download Presentation
David Evans cs.virginia/~evans

Loading in 2 Seconds...

play fullscreen
1 / 28

David Evans cs.virginia/~evans - PowerPoint PPT Presentation


  • 104 Views
  • Uploaded on

Lecture 8: Con’s 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 Sum. History of Scheme. Scheme [1975] Guy Steele and Gerry Sussman Originally “Schemer”

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'David Evans cs.virginia/~evans' - barth


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:

Con’s car cdr sdr wdr

David Evans

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

CS200: Computer Science

University of Virginia

Computer Science

slide2
Menu
  • History of Scheme
    • LISP
  • Lists
  • Sum

CS 200 Spring 2002

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 2002

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

making lists
Making Lists

CS 200 Spring 2002

making a pair
Making a Pair

> (cons 1 2)

(1 . 2)

1

2

consconstructs a pair

CS 200 Spring 2002

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 2002

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 2002

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 2002

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 2002

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 2002

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 2002

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 2002

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 2002

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 2002

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 2002

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 2002

slide19
Null

List ::= (consElementList)

List ::=

null

A list is either:

a pair where the second part is a list

or, empty (null)

CS 200 Spring 2002

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 2002

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 2002

slide22
Sum

CS 200 Spring 2002

friday
Friday

(sum n) = 1 + 2 + … + n

(define (sum n)

(for 1 n (lambda (acc i) (+ i acc)) 0))

(define (sum n)

(for 1 n + 0))

Can we use lists to define sum?

CS 200 Spring 2002

slide24
Sum

(define (sum n)

(insertl + (intsto n)))

(intsto n) = (list 1 2 3 … n)

(insertl + (list 1 2 3 … n)) =

(+ 1 (+ 2 (+ 3 (+ … (+ n)))))

CS 200 Spring 2002

intsto dyzlexic implementation
Intsto (Dyzlexic implementation)

;;; Evaluates to the list (1 2 3 … n) if n >= 1,

;;; null if n = 0.

(define (intsto n)

(if (= n 0) null

(cons n (intsto (- n 1)))))

CS 200 Spring 2002

intsto
Intsto?

;;; Evaluates to the list (1 2 3 … n) if n >= 1,

;;; null if n = 0.

(define (intsto n)

(if (= n 0) null

(list (intsto (- n 1)) n)))

> (intsto 5)

(((((() 1) 2) 3) 4) 5)

CS 200 Spring 2002

intsto1
Intsto

;;; Evaluates to the list (1 2 3 … n) if n >= 1,

;;; null if n = 0.

(define (intsto n)

(if (= n 0) null

(append (intsto (- n 1)) (list n))))

append puts two lists together

> (intsto 5)

(1 2 3 4 5)

CS 200 Spring 2002

charge
Charge
  • PS3 Out Today
    • Uses Lists to make fractals
    • Due next week Wednesday
  • Next time:
    • We’ll define insertl
      • Try to do this yourself! (Easier than defining for)

CS 200 Spring 2002