CSC302 2006S, Class 15: Scheme Semantics, Concluded
Admin:
* "Reading" Homework for Monday (please submit by 8 p.m. Sunday)
* Find or write a good definition of "object-oriented programming"
* Explain the diffence between polymorphism and overloading
* Semantics homework coming soon
* Issues of upcoming schedule
* Next Friday: Sam at SIGCSE - Video
* Following Friday: Freda turns 75 - Guest
* Following Monday: Returning from Friday - Guest
* Late: Dave, Mark
Overview:
* Notation and related issues
* Hold, revisited
* Function application
* Lambda definitions
* Other?
Some issues in reading the semantics:
* Makes a lot of use of continuations
* What does it mean that we're building continuations, given a continuation as one of our parameters?
* It means we're building things *backwards* - We have the continuation for the current expression (or statement) and are generating the continuation for the previous expression
* "Obvious" from the last equation on p. 41
The joy of currying
single takes a (E->C) as a parameter and returns a K
K is a function
\ psi . (\epsilon* . (something that computes a C))
\ psi epsilon* . (something that computes a C)
Type of single
single: (E->C) -> K
single: (E->C) -> E* -> C
If you provide single with one parameter, you get back a function that expects a sequence of expressed values
If you provide single with two parameters, you get back a command continuation.
Let's consider hold.
* hold is used in the definition of the value of an identifier
* We would expect to
* Verify that the identifier is defined (conditioanl)
* Find the location of the identifier (lookup)
* Find the value stored in that location (hold)
* Call that continuation on the value (maybe in the send?)
* Shove it all into a continuation (extra baggage, eg. single)
* How do we find the value stored in a location?
* With a store
* Where does the store come from?
* From the expression continuation (E* -> S -> C)
* hold must therefore help us get that store
* hold receives:
* a location
* an expression continuation (what to do with the value we look up)
* hold returns
* a command continuation
* hold : L -> K -> C
* hold : L -> K -> S -> A
* hold will need to look up the value in that store and call K on it
hold = \ alpha kappa sigma -> send ((sigma alpha) select 1) kappa sigma
Procedure call
Form: (E0 E*)
* Evaluate E0 and all of the other expressions (scriptE*)
* Apply the function (applicate)
* "Call" the continuation on the result
* Build a new continuation
Lambda:
* Hidden assumption: Every call to (new sigma) returns the same value
* We begin by attempting to allocate memory (for the return value?, for the function?)
Expectation for a function call
* Evaluate all the expressions (done in "procedure call")
* Allocate memory locations for each formal (update the symbol table and the store)
* Copy actuals into those memory locations
* Evaluate the body using that new store and symbol table