cs-4400-sp26

Lecture 3: LetLang, continued

Substitution

When we left off, we were starting to write our interpreter for LetLang, and we got to the following case:

[(letE var assignment body) ...]

Informally, what we want to do is:

• Evaluate assignment to a value: in this case, a number n
• Substitute n for instances of var in body
• Continue evaluating the result.

But we stopped short of defining what it means to “substitute n for var in body”. Let’s think through some examples. We’ll use some notation here: [n/x]e means “substitute n for x in e.”

1. Example 1: [7/x] x
   1. Result: 7
2. Example 2: [7/x] (x + x)
   1. Result: 7 + 7
3. Example 3: [7/x] (x + y)
   1. Result: 7 + y
4. Example 4: [7/x] x + (let y = 4 in y + x)
   1. Result: 7 + (let y = 4 in 7 + x)
5. Example 5: [7/x] 4
   1. Result: 4
6. Example 6: [7/x] (let x = 3 in x + x)
   1. Result: let x = 3 in x + x (note: shadowing!)

These examples should give us enough to generalize into a definition. We define substitution by induction (case analysis) on the expression being substituted into:

To substitute n for x in:
- A variable y:
  - if y = x, then (num n)
  - otherwise, y
- A number (num n):
  - Nothing to do: (num n)
- A sum (e1 + e2):
  - recursively substitute, and re-form the sum: ([n/x]e1 + [n/x]e2)
- A let-expression (let y = e1 in e2)
  - If y = x: substitute into e1, but do nothing to e2: 
    (let y = [n/x]e1 in e2)  --- note: this is the shadowing case
  - Otherwise: recursively substitute :
    (let y = [n/x]e1 in [n/x]e2)

In class, we’ll translate this definition into Plait code and test it on the examples above.

Now we can use the definition to complete our LetLang definitional interpreter.

Small-step semantics

So far, our notion of a definitional interpreter has allowed us to say that a program’s meaning is the value it runs to when it’s done running. However, this is not a very useful definition in all circumstances: for example, if we have programs that can run forever, or that periodically play noises or accept user input, we don’t care about only the “final result”.

Small-step semantics is an approach that takes this concern into account be explaining how to perform a single step of computation at a time for a given expression. You can think of it like each line of a math problem where you are asked to “simplify” an expression. For example:

(2 + 1) + (3 + 1)
--->
3 + (3 + 1)
--->
3 + 4
--->
7

We can kind of get the gist of what we’re doing by example. Note that this example shows a sequence of steps taken that eventually get to a value, but our step function will implement just a single ---> step.

Together, we will write a “stepper” that implements this behavior for LetLang. Here’s a pseudocode specification:

• To step x: error, unbound variable.
• To step e1 + e2:
  • If e1 and e2 are both numbers num n and num m:
    • Step to their sum: num (n + m)
  • If e1 can take a step to e1',
    • Step to e1' + e2
  • If e2 can take a step to e2',
    • Step to e1 + e2'.
• To step let x = e1 in e2:
  • If e1 can take a step to e1',
    • Step to let x = e1' in e2
  • Otherwise, e1 must be a num n.
    • Step to [n/x]e2
• To step num n: do nothing (return num n).

A few things to note and discuss:

• The stepper forces us to make explicit something that was previously implicit: when stepping (e1 + e2), which sub-expression should we evaluate first? Both choices are valid, but in some languages might change the program behavior (can you think of why?)
• We have a similar choice when evaluating a let . Our current definitional interpreter has us evaluate the assignment expression first, then substitute (which is why we can define substitution just over values). Are there reasons why we might want to make a different choice, where we substitute the whole assignment into the body first, and then evaluate the result?

Repeated stepping

Intuitively, we expect to be able to “call step repeatedly” to take an expression to its eventual value. Can we try make this intuition precise?

First, let’s say what it means to “step e some number k times”:

(stepk : (Number LetLang -> LetLang))
(define (stepk k e)
	(if (equal? k 0) 
		e 
		(stepk (- k 1) (step e))
	)
)

The following specification describes our intended behavior:

Whenever (interp e) produces a number n, there exists k such that (stepk k e) produces (numE n).

We can think of this as a relationship between two definitions of our language, a statement that they are, in some sense, the same. This will be a recurring idea throughout the course.