Looking back Write one thing you learned about higher-order and - - PowerPoint PPT Presentation

Looking back

Write one thing you learned about higher-order and anonymous functions. Your answers may be anonymously shared with your classmates.

Reflection

Consider the following algebraic laws for list reversal: reverse ’() = ’() reverse (x .. xs) = reverse xs .. reverse ’(x) = reverse xs .. ’(x) where .. denotes the append operation on lists. Now consder the corresponding code: (define reverse (xs) (if (null? xs) ’()

(append (reverse (cdr xs)) (list1 (car xs))))) where list1 is a function that makes a

• ne-element list from its argument.

Answer these questions:

• For a list reversal function to be considered to

have good performance, what should its running time be in terms of the length of its argument?

• What is the running time of the reverse

function above?

Naive list reversal

(define reverse (xs) (if (null? xs) ’() (append (reverse (cdr xs)) (list1 (car xs)))))

Tail calls

Intuition: In a function, a call is in tail position if it is the last thing the function does.

(define reverse (xs) (if (null? xs) ’() (append (reverse (cdr xs)) (list1 (car xs)))))

Tail calls

Intuition: In a function, a call is in tail position if it is the last thing the function does.

(define reverse (xs) (if (null? xs) ’() (append (reverse (cdr xs)) (list1 (car xs)))))

A tail call is a call in tail position.

What is tail position?

Tail position is defined inductively:

• The body of a function is in tail position
• When (if e1 e2 e3) is in tail position, so are

e2 and e3

• When (let (...) e) is in tail position, so is e,

and similary for letrec and let*.

• When (begin e1 ... en) is in tail position, so

is en. Idea: The last thing that happens

Check your understanding: Tail Position

Consider the following code

• > (define foldr (plus zero xs)

(if (null? xs) zero (plus (car xs) (foldr plus zero (cdr xs))))) Now answer the following questions. The occurrence of expression zero in the true-branch of the if expression is in tail position.

• True
• False

Answer: True. The body of the function is in tail

position, which makes the if expression itself in tail position. The rule for if is that the true and false branches share the tail status of the if expression, so zero is in tail position. The occurrence of expression plus in the false-branch of the if expression is in tail position.

• True
• False

Answer: True. The body of the function is in tail position, which makes the if expression itself in tail position. The rule for if is that the true and false branches share the tail status of the if

• expression. The call to plus is the last thing in the

false-branch, so it is in tail position. The occurrence of expression foldr in the false-branch of the if expression is in tail position.

• True
• False

Answer: False. The call to foldr is within the call to plus in the false-branch of the if expression, so it cannot be the last thing that happens.

Tail-call optimization & accumulating parameters

Tail-call optimization

• Anything in tail position is the last thing executed,

so its stack frame can be recycled

• Before executing a call in tail position,

abandon current stack frame

• Results in asymptotic space savings

Accumulating Parameter

• Add a parameter to accumulate answer
• Moves recursive call to tail position

Example: Accumulating reverse function

Key ideas:

• Recursive call is in a tail position
• Accumulating parameter collects answer

Contract: (revapp xs ys) = (append (reverse xs) ys) Laws: (revapp ’() ys) == ys (revapp (cons z zs) ys) == (revapp zs (cons z ys))

Reversal by accumulating parameters

; laws: (revapp ’() ys) = ys ; (revapp (cons z zs) ys) = ; (revapp zs (cons z ys)) (define revapp (xs ys) ; return (append (reverse xs) ys) (if (null? xs) ys (revapp (cdr xs) (cons (car xs) ys)))) (define reverse (xs) (revapp xs ’()))

Tail position in revapp

(define revapp (xs zs) (if (null? xs) zs (revapp (cdr xs) (cons (car xs) zs))))

Tail position in revapp

(define revapp (xs zs) (if (null? xs) zs (revapp (cdr xs) (cons (car xs) zs))))

Values xs and zs go in machine registers. Code compiles to a loop.

Check your understanding: Accumulating Parameters

An accumulating parameter to a recursive function f accumulates the answer so that a recursive call to f can be in tail position.

• True
• False

Answer: True. The stack frame of a function call that is not in tail position cannot be shared with subsequent calls because its values may still be needed.

• True

• False

Answer: True. Tail-call optimizations and the use of accumulating parameters can only result in constant-time improvements to the complexity of a function.

• True
• False

Answer: False. The revapp version of the reverse function is linear in the length of the list being reversed while the naive version of reverse is quadratic.

Reflection

Are tail calls familiar? What other programming construct

• 1. Transfers control to another point in the code?
• 2. Uses no stack space?

Tail calls as gotos with arguments

Gotos

• Transfer control to another point in the code
• Use no stack space
• Can only go to code marked with labels

Tail calls

• Transfer control to another point in the code
• Use no stack space
• Can transfer control to any function
• Can take parameters!

Continuations: First-class tail calls

A continuation is code that represents “the rest of the computation.”

• Not a normal function call because

continuations never return

• Think “goto with arguments”

Context: an advanced technique, heavily used in event-driven programming:

• GUIs, games, web, embedded devices

Different coding styles

Direct style

• Last action of a function is to return a value.

(This style is what you are used to.) Continuation-passing style (CPS)

• Last action of a function is to “throw” answer to

a continuation. (For us, tail call to a parameter.)

Uses of continuations

• Compiler representation:

– Compilers for functional languages often convert direct-style user code to CPS because CPS matches control-flow of assembly.

• First-class continuations.

– Some languages provide a construct for capturing the current continuation and giving it a name k. – Control can be resumed at captured continuation by throwing to k.

• A style of coding that can mimic exceptions
• Callbacks in GUI frameworks and web services
• Event loops in game programming and other concurrent

settings

Implementation

• We’re going to simulate continuations with

function calls in tail position.

• First-class continuations require compiler

support. – primitive function that materializes “current continuation” into a variable.

Check your understanding: Continuation Introduction

A continuation is different from a normal function because it never returns to the context from which it was invoked.

• True
• False

Answer: True. Continuations cannot take arguments.

• True
• False

Answer:False.

Continuations are used in GUI frameworks and to mimic exceptions.

• True
• False

Answer: True.

Reflection

Consider the following algebraic laws for a witness function: (witness p? xs) == x, where (member x xs), provided (exists? p? xs) Now answer this questions:

• What should the function do if there exists no

such x?

Design Problem: Missing Value

Provide a witness to existence: (witness p? xs) == x, where (member x xs), provided (exists? p? xs) Problem: What if there exists no such x? Bad ideas:

• nil
• special symbol fail
• run-time error

Good idea: exception (but not available in uScheme)

Solution: A New Interface

Success and failure continuations! Contract written using properties (not algorithmic) (witness-cps p? xs succ fail) = (succ x) ; where x is in xs and (p? x) (witness-cps p? xs succ fail) = (fail) ; where (not (exists? p? xs))

From contract to laws

(witness-cps p? xs succ fail) = (succ x) ; where x is in xs and (p? x) (witness-cps p? xs succ fail) = (fail) ; where (not (exists? p? xs))

Where do we have forms of data?

(witness-cps p? ’() succ fail) = ? (witness-cps p? (cons z zs) succ fail) = ? ; when (p? z) (witness-cps p? (cons z zs) succ fail) = ? ; when (not (p? z))

Coding witness with continuations

(define witness-cps (p? xs succ fail) (if (null? xs) (fail) (let ([z (car xs)]) (if (p? z) (succ z) (witness-cps p? (cdr xs) succ fail)))))

“Continuation-Passing Style” by laws

The right-hand side of every law calls a parameter (witness-cps p? xs succ fail) = (succ x) ; where x is in xs and (p? x) (witness-cps p? xs succ fail) = (fail) ; where (not (exists? p? xs))

“Continuation-Passing Style” by code

All tail positions are continuations or recursive calls

(define witness-cps (p? xs succ fail) (if (null? xs) (fail) (let ([z (car xs)]) (if (p? z) (succ z) (witness-cps p? (cdr xs) succ fail)))))

Compiles to tight code

Example Use: Instructor Lookup

• > (val 2020f ’((Fisher 105)(Monroe 40)(Chow 116)))
• > (instructor-info ’Fisher 2020f)

(Fisher teaches 105)

• > (instructor-info ’Chow 2020f)

(Chow teaches 116)

• > (instructor-info ’Votipka 2020f)

(Votipka is-not-on-the-list)

Instructor Lookup: The Code

; info has form: ’(Fisher 105) ; classes has form: ’(info_1

• info_n)

(define instructor-info (instructor classes) (let ( [s (lambda (info) ; success continuation (list3 instructor ’teaches (cadr info)))] [f (lambda () ; failure continuation (list2 instructor ’is-not-on-the-list))]) (witness-cps pred classes s f))

Instructor Lookup: The Code

; info has form: ’(Fisher 105) ; classes has form: ’(info_1

• info_n)

(define instructor-info (instructor classes) (let ( [s (lambda (info) ; success continuation (list3 instructor ’teaches (cadr info)))] [f (lambda () ; failure continuation (list2 instructor ’is-not-on-the-list))]) (witness-cps (o ((curry =) instructor) car) classes s f))

Instructor Lookup: The Code

; info has form: ’(Fisher 105) ; classes has form: ’(info_1

• info_n)

(define instructor-info (instructor classes) (let ( [s (lambda (info) ; success continuation (list3 instructor ’teaches (cadr info)))] [f (lambda () ; failure continuation (list2 instructor ’is-not-on-the-list))]) (witness-cps (o ((curry =) instructor) car) classes s f))

Instructor Lookup: The Code

; info has form: ’(Fisher 105) ; classes has form: ’(info_1

• info_n)

(define instructor-info (instructor classes) (let ( [s (lambda (info) ; success continuation (list3 instructor ’teaches (cadr info)))] [f (lambda () ; failure continuation (list2 instructor ’is-not-on-the-list))]) (witness-cps (o ((curry =) instructor) car) classes s f)))

Coding Interlude: witness-cps

Consider the following code: (define witness-cps (p? xs succ fail) (if (null? xs) (fail) (let ([z (car xs)]) (if (p? z) (succ z) (witness-cps p? (cdr xs) succ fail))))) (val 2020f ’((Fisher 105)(Monroe 40)(Chow 116)))

(define instructor-info (instructor classes) (let ( [s (lambda (info) ; success continuation (list3 instructor ’teaches (cadr [f (lambda () ; failure continuation (list2 instructor ’is-not-on-the-list))]) (witness-cps (o ((curry =) instructor) car) classes s f))) (instructor-info ’Fisher 2020f) (instructor-info ’Chow 2020f) (instructor-info ’Votipka 2020f) Modify the code to add another professor and

course number, and add a test case for that professor. Run your code. Modify the code to return 'is-not-teaching-this-semester if the instructor’s name is not on the list. Run your code to confirm it returns your new response when given a name not on the list. Explain how would you modify the code to search for a course number instead of an instructor name.