Announcements

1
Announcements

• See web page for talk schedule
• Dire consequences if I dont hear from you by
  Monday
• Schedule next week
• Monday class as usual
• Wednesday class as usual
• immediately after class I go to Chicago for
  data mining conference, return Sunday (will be
  checking email)
• Friday class as usual Les LaCroix from ITS
  will talk about scripting languages

2
Scheme Lists

• Lists are a special form of S-Expressions
• () represents the empty list
• (A) represents list contains A
• (A) is really (A . ())
• (A B) is really (A . (B . () ) )
• (picture on blackboard)

3
Function Calls

• Function calls represented as lists
• (A B C) means
• evaluate A to a function, evaluate B and C as
  parameters
• Use the value returned by the call as the
  "meaning" of (A B C)
• Why does (car (1 2)) fail?
• (1 2) looks like a function call, but 1 isn't a
  function. quote function says "don't evaluate"
• (car (quote (1 2)))
• shorthand (car '(1 2))

4
User-defined functions

• The list (lambda (args) (body))creates an
  anonymous function
• (lambda (x y) ( x y))
• ((lambda (x y) ( x y)) 5 6) gt 11

5
User-defined functions

• The scheme command define binds values and
  functions to symbols
• (define pi 3.14159265)
• (define add-two-nums (lambda (x y) ( x y)))
• Abbreviated as(define add-two-nums (x y) ( x
  y))
• Functions in Scheme are first-class objects
  treated just like any other data type

6
Recursion

• Breaks a problem down into simpler or smaller
  problems
• Mentality If trivial case then supply
  answer else supply part of answer combined
  with solution of smaller problem

7
Example nth function
8
Example nth function

• (define (nth input n) (if ( n 0) (car input)
  (nth (cdr input) (- n 1))))

9
Example copy-list
10
Example copy-list

• (define (copy-list input) (cond (( (length
  input) 0) ()) (( (length input) 1)
  (list (car input))) (else (cons (car
  input) (copy-list (cdr input))))))

11
Let and side effects

• let is used to create local variables
• example in DrScheme
• let is good for preventing functions from
  affecting the outside world
• A side effect is when a function changes either
  one if its parameters or a global variable
• Scheme uses the ! as a convention to indicate
  that a function changes an argument

12
Subsets

• How can we define a Scheme function to create a
  subset?
• (subsets (1 2 3)) gt ( () (1) (2) (3) (1 2)
  (1 3) (2 3) (1 2 3))
• Number of subsets of n1 values is twice as many
  as subsets of n values
• If we have subsets of (1 2), get subsets of (1 2
  3) by duplicating all subsets of(1 2) and adding
  3

13
Subsets

• Define distrib function to add a new element to a
  list of lists(distrib (() (1) (2) (1 2)) 3) gt
  ( (3) (3 1) (3 2) (3 1 2))
• (define (distrib L E) (if (null? L) ()
  (cons (cons E (car L)) (distrib (cdr
  L) E))))
• Then define an extend function to attach these
  two together

14
Subsets

• (define (extend L E) (append L (distrib L E)))
• Then defining the subsets code is easy
• (define (subsets L) (if (null? L) (list
  ()) (extend (subsets (cdr L))
  (car L))))

15
Accessing elements of a list

• (list-tail L k)
• returns tail of a list after removing first k
  elements
• (list-ref L k)
• pulls off the k-th element
• Both of these can be slow since lists are linked
  lists

16
Still have not heard from a handful of people

• No language or date, but paired
• Mark Peralta / Chris Middleton
• Language but no date
• Robin Smogor / Jenny Cooper
• Paired? Language? Date?
• Scott OReilly / Thorin Tatge
• No contact at all
• Kevin DeRonne
• Shaun Reynolds
• Ryan Wakeham
• Chris Ghere
• Steve Fritzdixon
• Looking for partner
• Akira Matoba
• If you have not contacted me at all by the end of
  the day today (via email), drop a letter grade on
  the talk
• If you do not have a language and date scheduled
  before class on Wednesday, same penalty

17
Vectors

• Better to use vectors if accessing multiple
  elements of a list
• (define x (1 2.0 three))
• (vector-ref x 2)
• vector-gtlist and list-gtvector convert back and
  forth
• -gt is Scheme convention for a conversion
  function

18
Lookup tables

• Scheme function assoc does lookup in a list
• (define my-list ( (a 10) (b 20) (c
  30))(assoc b my-list)
• Can do it with non-atomic keys too
• (define price-list ( ( (subaru forester)
  21000) ( (toyota rav4) 23000) ( (honda
  cr-v) 21200) ))(assoc (toyota rav4) price-list)

19
Nasty Scheme functions

• set-car!
• set-cdr!
• examples

20
Scoping

• Scheme has lexical scoping. Any variables which
  are non-local are bound to containing lambda
  parameters, let values, or globally defined
  values.
• Example(define (f x) (lambda (y) ( x y)))
• f takes one parameter, x. It returns a function
  of y.
• (f 10) gt (lambda (y) ( 10 y))

21
Scoping

• Unbound symbols are assumed to be globals
• Let is a good way to encapsulate internal
  variables
• (define cnt (let ( (I 0) ) (lambda ()
  (set! I ( I 1)) I)))
• Try it by executing the function (cnt) repeatedly

22
Let bindings can be subtle

• Notice the difference in behavior between these
  two programs
• (define cnt (let ( (I 0) ) (lambda ()
  (set! I ( I 1)) I)))
• (define cnt (lambda () (let ( (I 0) )
  (set! I ( I 1)) I)))

23
Sharing vs. Copying

• If there were no side effects, would never need
  to copy an object just copy pointers
• If there are side effects, sometimes need to copy
  entire objects
• (define A (1 2))(define B (cons A A))B ( (1
  2) 1 2)
• show picture
• (set-car! (car B) 10)

24
Copying Scheme objects

• (define (copy obj) (if (pair? obj) (cons
  (copy (car obj)) (copy (cdr obj)))
  obj))

25
Shallow Deep Copying

• Shallow copy just copies a reference
• Deep copy copies the entire object
• In Java (similar to C)
• Object O1 new Object()
• Object O2
• O2 O1 // shallow copy
• Java has a clone operation
• O2 O1.clone()
• ... but anything referenced by the object is
  shallow copied (unless you overload clone)

26
Equality Checking

• Pointer equivalence do the two operands point
  to the same address?
• Structural equivalence do the two operands
  point to identical structures, even if in
  different locations?
• Pointer equivalence is faster but may not be what
  you want
• eqv? and eq? are pointer equivalence
• equal? is structural equivalence
• equal? is usually what you want (but slower)

27
Loops

• Look like recursion
• (let loop ((x 1) (sum 0)) if (lt x 10)
  (loop ( x 1) ( sum x)) sum))
• Sums the values from 1 to 10 and displays it
• Similar to
• for (x1 x lt 10 sum x, x)cout ltlt sum

28
Control Flow in Scheme

• Schemes control flow is normally simple and
  recursive
• First argument is evaluated to get a function
• Remaining arguments are evaluated to get actual
  parameters
• Actual parameters are bound to functions formal
  parameters
• Function body is evaluated to obtain function
  call value
• Leads to deeply nested expression evaluation.

29
Example Multiply a list of integers

• (define (mult-list L) (if (null? L) 1
  ( (car L) (mult-list (cdr L)))))
• The call (mult-list (1 2 3 4 5))expands to (
  1 ( 2 ( 3 ( 4 ( 5 1)))))
• Get clever if a 0 appears anywhere in the list,
  the product must be 0.

30
Improved multiply

• (define (mult-list L) (cond ((null? L) 1)
  (( 0 (car L)) 0) (else ( (car L)
  (mult-list (cdr L)))))))
• Better than above but still do lots of
  unnecessary multiplications (until you hit zero)
• Can we escape from a sequence of nested calls
  once we know theyre unnecessary?

31
Exceptions

• C handles this problem with exceptions
• struct Node int val Node next

32
C Exceptions

• int mult (Node L) try return
  multNode(L) catch (int returnCode)
  return returnCode int multNode(Node L)
  if (L NULL) return 1 else if (L-gtval
  0) throw 0 else return L-gtval
  multNode(L-gtnext)

33
Scheme Continuations

• A continuation is a Scheme mechanism for storing
  what you should do with a return value.
• Two different styles
• Implement your own
• Built in Scheme mechanisms

34
Scheme continuations

• http//www.cs.utexas.edu/users/wilson/schintro/sch
  intro_127.htmlSEC171
• http//www.cs.utexas.edu/users/wilson/schintro/sch
  intro_141.htmlSEC264
• In most languages, calling a function creates a
  stack frame that holds return address for call
  and variable bindings
• In Scheme, everything is stored in garbage
  collected heap
• Whenever you call a function, you get a pointer
  to the calling function partial continuation
  (draw picture)

35
Scheme continuations

• Scheme actually lets you manipulate these
  continuations. This is weird!
• Scheme function
• call-with-current-continuation
• can be abbreviated as call/cc
• Call/cc is used to call another function, but it
  passes along the current continuation as an
  argument.

36
Continuations example

• (define (resumable-fun) (display 1) (display
  (call/cc abortable-fun)) (display 2))(define
  (abortable-fun escape-fun) (display a) (if
  (bad-thing-happens) (escape-fun 0))
  (display b))(resumable-fun)

37
Continuations with multiply

• Problem how to use call/cc with an argument?
• (define (mult-list L) (call/cc mult-list-main
  L)) this is bad code cant take a
  list
• Trick have call/cc call an anonymous function
• (define (mult-list L) (call/cc (lambda
  (escape) (mult-list L escape)))

38
Multiply with continuations

• (define (mult-list-main L escape) (cond
  ((null? L) 1) ((0 (car L)) escape 0)
  (else ( (car L) (mult-list-main
  (cdr L) escape)))) (define (mult-list L)
  (call/cc (lambda (escape)
  (mult-list-main L escape)))

39
Implement your own continuation

• con has to be done multiplications(define
  (mult-list L con) (cond ((null? L) (con
  1)) (( 0 (car L) 0) (else (mult-list
  (cdr L) (lambda (n) ( n
  (con (car L)))))))
• To actually call the function
• (define (id x) x)(mult-list (1 2 3) id)