Announcements

1. Announcements • See web page for talk schedule • Dire consequences if I don’t 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) => 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)) => ( () (1) (2) (3) (1 2) (1 3) (2 3) (1 2 3)) • Number of subsets of n+1 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) => ( (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 O’Reilly / 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->list and list->vector convert back and forth • “->” 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) => (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 (<= x 10) (loop (+ x 1) (+ sum x)) sum)) • Sums the values from 1 to 10 and displays it • Similar to • for (x=1; x <= 10; sum += x, x++){};cout << sum;

28. Control Flow in Scheme • Scheme’s 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 function’s 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 they’re 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->val == 0) throw 0; else return L->val * multNode(L->next);}

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/schintro_127.html#SEC171 • http://www.cs.utexas.edu/users/wilson/schintro/schintro_141.html#SEC264 • 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 – can’t 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)