Dynamic versus Lexical Scope

And back to the discussion of whether we should use dynamic or lexical scope:

• The most important fact is that we want to view programs as executed by the normal substituting evaluator. Our original motivation was to optimize evaluation only — not to change the semantics! It follows that we want the result of this optimization to behave in the same way. All we need is to evaluate:

  (run "{with {x 3}
          {with {f {fun {y} {+ x y}}}
            {with {x 5}
              {call f 4}}}}")

  in the original evaluator to get convinced that 7 should be the correct result (note also that the same code, when translated into Racket, evaluates to 7).

  (Yet, this is a very important optimization, which without it lots of programs become too slow to be feasible, so you might claim that you’re fine with the modified semantics…)

• It does not allow using functions as objects, for example, we have seen that we have a functional representation for pairs:

  (define (kons x y)
    (lambda (n)
      (match n
        ['first  x]
        ['second y]
        [else (error ...)])))
  
  (define my-pair (kons 1 2))

  If this is evaluated in a dynamically-scoped language, we do get a function as a result, but the values bound to x and y are now gone! Using the substitution model we substituted these values in, but now they were only held in a cache which no has no entries for them…

  In the same way, currying would not work, our nice deriv function would not work etc etc etc.

• Makes reasoning impossible, because any piece of code behaves in a way that cannot be predicted until run-time. For example, if dynamic scoping was used in Racket, then you wouldn’t be able to know what this function is doing:

  (define (foo)
    x)

  As it is, it will cause a run-time error, but if you call it like this:

  (let ([x 1])
    (foo))

  then it will return 1, and if you later do this:

  (define (bar x)
    (foo))
  
  (let ([x 1])
    (bar 2))

  then you would get 2!

  These problems can be demonstrated in Emacs Lisp too, but Racket goes one step further — it uses the same rule for evaluating a function as well as its values (Lisp uses a different name-space for functions). Because of this, you cannot even rely on the following function:

  (define (add x y)
    (+ x y))

  to always add x and y! — A similar example to the above:

  (let ([+ -])
    (add 1 2))

  would return -1!

• Many so-called “scripting” languages begin their lives with dynamic scoping. The main reason, as we’ve seen, is that implementing it is extremely simple (no, nobody does substitution in the real world! (Well, almost nobody…)).

  Another reason is that these problems make life impossible if you want to use functions as object like you do in Racket, so you notice them very fast — but in a normal language without first-class functions, problems are not as obvious.

• For example, bash has local variables, but they have dynamic scope:

  x="the global x"
  print_x() { echo "The current value of x is \"$x\""; }
  foo() { local x="x from foo"; print_x; }
  print_x; foo; print_x

  Perl began its life with dynamic scope for variables that are declared local:

  $x="the global x";
  sub print_x { print "The current value of x is \"$x\"\n"; }
  sub foo { local($x); $x="x from foo"; print_x; }
  print_x; foo; print_x;

  When faced with this problem, “the Perl way” was, obviously, not to remove or fix features, but to pile them up — so local still behaves in this way, and now there is a my declaration which achieves proper lexical scope (and every serious Perl programmer knows that you should always use my)…

  There are other examples of languages that changed, and languages that want to change (e.g, nobody likes dynamic scope in Emacs Lisp, but there’s just too much code now).

• This is still a tricky issue, like any other issue with bindings. For example, googling got me quickly to a Python blog post which is confused about what “dynamic scoping” is… It claims that Python uses dynamic scope (Search for “Python uses dynamic as opposed to lexical scoping”), yet python always used lexical scope rules, as can be seen by translating their code to Racket (ignore side-effects in this computation):

  (define (orange-juice)
    (* x 2))
  (define x 3)
  (define y (orange-juice)) ; y is now 6
  (define x 1)
  (define y (orange-juice)) ; y is now 2

  or by trying this in Python:

  def orange_juice():
    return x*2
  def foo(x):
    return orange_juice()
  foo(2)

  The real problem of python (pre 2.1, and pre 2.2 without the funny

  from __future__ import nested_scope

  line) is that it didn’t create closures, which we will talk about shortly.

• Another example, which is an indicator of how easy it is to mess up your scope is the following Ruby bug — running in irb:

  % irb
  irb(main):001:0> x = 0
  => 0
  irb(main):002:0> lambda{|x| x}.call(5)
  => 5
  irb(main):003:0> x
  => 5

  (This is a bug due to weird scoping rules for variables, which was fixed in newer versions of Ruby. See this Ruby rant for details, or read about Ruby and the principle of unwelcome surprise for additional gems (the latter is gone, so you’ll need the web archive to read it).)

• Another thing to consider is the fact that compilation is something that you do based only on the lexical structure of programs, since compilers never actually run code. This means that dynamic scope makes compilation close to impossible.

• There are some advantages for dynamic scope too. Two notable ones are:

  • Dynamic scope makes it easy to have a “configuration variable” easily change for the extent of a calling piece of code (this is used extensively in Emacs, for example). The thing is that usually we want to control which variables are “configurable” in this way, statically scoped languages like Racket often choose a separate facility for these. To rephrase the problem of dynamic scoping, it’s that all variables are modifiable.

    The same can be said about functions: it is sometimes desirable to change a function dynamically (for example, see “Aspect Oriented Programming”), but if there is no control and all functions can change, we get a world where no code can every be reliable.

  • It makes recursion immediately available — for example,

    {with {f {fun {x} {call f x}}}
      {call f 0}}

    is an infinite loop with a dynamically scoped language. But in a lexically scoped language we will need to do some more work to get recursion going.

Implementing Lexical Scope: Closures and Environments

So how do we fix this?

Lets go back to the root of the problem: the new evaluator does not behave in the same way as the substituting evaluator. In the old evaluator, it was easy to see how functions can behave as objects that remember values. For example, when we do this:

the result was a function value, which actually was the syntax object for this:

Now if we call this function from someplace else like:

it is clear what the result will be: f is bound to a function that adds 1 to its input, so in the above the later binding for x has no effect at all.

But with the caching evaluator, the value of

is simply:

and there is no place where we save the 1 — that’s the root of our problem. (That’s also what makes people suspect that using lambda in Racket and any other functional language involves some inefficient code-recompiling magic.) In fact, we can verify that by inspecting the returned value, and see that it does contain a free identifier.

Clearly, we need to create an object that contains the body and the argument list, like the function syntax object — but we don’t do any substitution, so in addition to the body an argument name(s) we need to remember that we still need to substitute x by 1 . This means that the pieces of information we need to know are:

and that last bit has the missing 1. The resulting object is called a closure because it closes the function body over the substitutions that are still pending (its environment).

So, the first change is in the value of functions which now need all these pieces, unlike the Fun case for the syntax object.

A second place that needs changing is the when functions are called. When we’re done evaluating the call arguments (the function value and the argument value) but before we apply the function we have two values — there is no more use for the current substitution cache at this point: we have finished dealing with all substitutions that were necessary over the current expression — we now continue with evaluating the body of the function, with the new substitutions for the formal arguments and actual values given. But the body itself is the same one we had before — which is the previous body with its suspended substitutions that we still did not do.

Rewrite the evaluation rules — all are the same except for evaluating a fun form and a call form:

As a side note, these substitution caches are a little more than “just a cache” now — they actually hold an environment of substitutions in which expression should be evaluated. So we will switch to the common environment name now.:

In case you find this easier to follow, the “flat algorithm” for evaluating a call is:

Note how the scoping rules that are implied by this definition match the scoping rules that were implied by the substitution-based rules. (It should be possible to prove that they are the same.)

The changes to the code are almost trivial, except that we need a way to represent <{fun {x} B}, env> pairs.

---

The implication of this change is that we now cannot use the same type for function syntax and function values since function values have more than just syntax. There is a simple solution to this — we never do any substitutions now, so we don’t need to translate values into expressions — we can come up with a new type for values, separate from the type of abstract syntax trees.

When we do this, we will also fix our hack of using FLANG as the type of values: this was merely a convenience since the AST type had cases for all kinds of values that we needed. (In fact, you should have noticed that Racket does this too: numbers, strings, booleans, etc are all used by both programs and syntax representation (s-expressions) — but note that function values are not used in syntax.) We will now implement a separate VAL type for runtime values.

First, we need now a type for such environments — we can use Listof for this:

but we can just as well define a new type for environment values:

Reimplementing lookup is now simple:

… we don’t need extend because we get Extend from the type definition, and we also get (EmptyEnv) instead of empty-subst.

We now use this with the new type for values — two variants of these:

And now the new implementation of eval which uses the new type and implements lexical scope:

We also need to update arith-op to use VAL objects. The full code follows — it now passes all tests, including the example that we used to find the problem.