Go Example Inspired by Lambda Calculus
======================================

The following code example shows that Go_ avoids capturing free variables in
closures.

::

    package main

    import "fmt"

    // Notice here that the variable a is defined as a local variable inside f,
    // and is also used inside the anonymous function that is returned. Thus f
    // returns a closure.
    func f(n int) func() int {
        a := 3
        return func() int {
            return n + a
        }
    }

    // If a was not defined locally, then we'd get a compiler error, e.g. this
    // function doesn't compile in Go:
    //
    //    func f(n int) func() int {
    //        return func() int {
    //            return n + a  // compiler error: a undefined
    //        }
    //    }
    //

    // Here, g ha a local variable named a. What happens if f has a free variable
    // named a? Does it use the value of a defined here, i.e. 5? Answer: no, the
    // passed-in function f does not use the a in g. That would be a kind of
    // variable capture that we could, in general, not predict! You often have no
    // idea of the names of the local variables in a function, so if the free
    // variables in a passed-in function were captured, you could get undefined
    // and unexpected behaviour.
    func g(f func() int) {
        a := 5
        fmt.Println("a =", a)
        fmt.Println(f())
    }

    func main() {
        add := f(5)
        fmt.Println(add()) // prints 8
        g(add)             // a = 5, 8
    }