CSC/ECE 517 Fall 2011/ch1 1d ss

Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.

Introduction

We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

statically vs dynamically typed

One simple way to differentiate between the two is:
In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of statically typed : C,C++,Java,JADE,Pascal etc
Examples of dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.[1]

Closures

In the words of Matsumoto, the creator of Ruby language: A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. [2]

what exactly is Closure

• A closure is a first-class block of code that has access to the environment in which it was defined.
  • A first class function is one that can be passed around just like any other object.
  • The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
      int y = 4;
      Func<int, int> myfunc = x => { return x+y; };
      return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.

Advantages of Closures

• It allows access to contextual information that wouldn’t be available inside a standard method of a class.
• It can be passed around as an object and retain that context, even if the variables are outside their original scope.
  
• There is no need to pass around internal variables for every call.
• Offers a more concise and clean method of programming operations.

Implementation of Closures

In dynamically typed languages

Example in Ruby

Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.

class SomeClass
def initialize(value1)
    @value1 = value1
  end

  def value_printer(value2)
    lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
  end
end

def caller(some_closure)
  some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [3]

Example in JS

we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
    var _privateProperty = "some value";
    function _privateMethod() {
        //perform some stuff
    }
    return {
        publicProperty: "some value",
        publicMethod: function publicMethod() {
            //perform some stuff
        }
    }
}()); 

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else. [4]

Example in Python

def makeInc(x):
  def inc(y):
     # x is "closed" in the definition of inc
     return y + x
 return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[5]

statically typed languages, difficulty

• We can explain this via an example.

Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[1]

• Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope.
• In order to accomplish this, the compiler must somehow keep the associated variables even when they go out of scope. In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. Also,in the case of Java and C# the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

Closures and Static Scoping

Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [6] Implementing static scope in a language that supports closures can be very challenging.

• It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
• When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.

For example in Ruby if we have this code:

 $arr = Array.new
 def funcGen(val)
   0.upto(val)
   do |i|
     $arr[i] = Proc.new {                
                 print i 
                 }
   end
 end
 funcGen(4)
 $arr.each
 do |val|
   val.call
 end

We will have an output similiar to this: 01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

   delegate void Func();
   class Program
   {
       static Func[] funcArr = new Func[4];
       static void Main(string[] args)
       {
           fillFunc(funcArr.Length); 
           for (int i = 0; i < funcArr.Length; i++) 
           { 
               funcArr[i](); 
           }
       }
       static void fillFunc(int count) 
       { 
           for (int i = 0; i < count; i++)
           { 
               //int j = i;
               funcArr[i] = delegate() { Console.Write("{0}", i); };      
           } 
       }
   }

We will have this output. 4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [7]

References

[1] Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"