CS 152 - Lecture 13

Cover page image

Scope

Scope of named entity = region where name references the entity
Scopes can overlap

class Example // Java
{
private int foo;
public void fun(double foo) {
    System.out.println(foo); // Which foo? 
  }
  public void fun() {
    System.out.println(foo); // Which foo? 
  }
}

Particularly common in languages with nested functions

def fun(x : Int) { // Scala
  def helper() { var x : Int; ... }
  ...
}

Static vs. Dynamic Scoping

Static scope: Depends on program source only
Dynamic scope: Depends on execution history

Example

val x = 1;
def f(y) = x + y;
def g() { val x = 2; f(x) };
g()

Static scoping: Result is 1 + 2
Dynamic scoping: Result is 2 + 2
Dynamic scoping is common in interpreted languages (see lab)
Disadvantage: Meaning of program harder to understand

Implementation of Dynamic Scoping

Global symbol table
Push definition when it is encountered, pop at end of scope

Example:

val x = 1;
def f(y) = x + y;
def g() { val x = 2; f(x) };
g()

x -> 1 // first def. of x
x -> 2, x -> 1 // def. of x inside g
y -> 2, x -> 2, x -> 1 // def. of parameter y

Implementation of Static Scoping

Each function has its own symbol table
Records the meanings of symbols when the function was defined
Function body is evaluated with that table (augmented by parameter bindings)

Example:

val x = 1;
def f(y) = x + y; // x -> 1
def g() { val x = 2; f(x) }; // f -> ...

Table only needs to store free variables in function body

When f is executed:
```
y -> 2, x -> 1
```

Implementing Recursive Functions

Can't use val:

val fac = x => if (x == 0) 1 else x * fac(x - 1)

RHS is an anonymous function with free variable fac
```
x => if (x == 0) 1 else x * fac(x - 1)
```
Then a new variable fac is defined

def simultaneously adds fac and RHS to symbol table

case class Closure(params : List[String], body : Block, var env : List[(String, Any)])
 ...
def evalDef(symbols : List[(String, Any)], defn : Definition) =
  defn match {
    case Defdef(name, Function(params, body)) => {
      val cl = Closure(params, body, symbols)
      val syms = (name, cl) :: symbols
      cl.env = syms // mutation
      syms
    }
    ...
  }

Here, for the first time, we use a var in Scala.
Pure functional solution is possible but complex (Google for Y combinator).

Lab

You work with a buddy
One of you writes the code (coder), the other types up answers (scribe)
When you get stuck, ask your buddy first!
Switch roles each lab. The previous scribe is the coder for this lab.
The scribe submits lab work in lab12/report.txt inside the Git repo. Include the coder's name in the report!
If the coder wants to submit something, that's cool too. Do whatever is easy.

Step 1: Bash

Launch your bash shell.
Next, some background information. The bash command shell has a rudimentary programming language. Here are some of its features.
1. You declare global variables with the syntax
```
varname=initialValue
```
2. You declare functions with the syntax
```
function funname {
   . . .
}
```
  Function parameters are not named. Instead, you refer to them as $1, $2, $3...
3. You call functions with the syntax
```
funname arg1 arg2 arg3 . . .
```
4. You declare local variables (inside functions) with the syntax
```
local varname=initialValue
```
5. You get the value of a variable with the syntax
```
$varname
```
  For example, the command
```
echo $a
```
  prints the value of a

Step 1: Bash (Continued)

Make a file test1.bash with the contents

x="2"

function f {
   echo $x
}

function main {
   local x="3" ; 
   f ;
}

main

Start the bash shell. Run the program: source test1.bash. What does it print?
What does that tell you about variable scoping in the bash language?

Step 2: More Bash

Make a file test2.bash with the contents.

x="2"

function f {
   echo $x
}

function g {
   local x="3" ; 
   f ;
}

function main {
   local x="4" ;
   f ;
   g ;
   f ;
}

f ;
main

What do you expect this program to print?

Start the bash shell. Run the program: source test2.bash. What does it print?
Explain the behavior by drawing diagrams of the symbol table.

Step 3: Understanding Closures in SL1

Consider the SL1 program

val a = 3;
val f = { x => x * a };
val g = { a => a * f(a)};
g(1)

What result output do you expect?

Start the SL1 interpreter from the previous lab and run the program. What output did you get?
Place a breakpoint in the line
```
case Valdef(name, Function(params, body)) => { (name, Closure(params, body, symbols)) :: symbols }
```
Run the debugger with the same program as input. When the breakpoint is hit, inspect symbols. What do you get for symbols when the definitions of f and g are evaluated?
Change the code for
```
case Funcall(fun, args) => eval(fun, symbols) match
```
to
```
case Funcall(fun, args) => val funval = eval(fun, symbols); funval match
```
Debug the program again, this time with a breakpoint in the line
```
evalBlock(body, params.zip(args.map(eval(_, symbols))) ::: syms)
```
The breakpoint will be triggered when g and f are executed. What are the values of symbols and the syms in the closure object when g is executed?
With what symbol table is the body of f executed?