CSC/ECE 517 Fall 2012/ch1 1w32 cm: Difference between revisions
| Line 43: | Line 43: | ||
</pre> | </pre> | ||
This would be replaced (if Java had closures) with: | |||
<pre> | <pre> | ||
Revision as of 22:47, 13 September 2012
CLOSURES FOR STATICALLY TYPED LANGUAGES
INTRODUCTION
A closure is a function or reference to a function which has a referencing environment — a table storing a reference to each of the non-local variables (also called free variables) of that function.1. A closure allows a function to access the non-local variables even outside its lexical scope. Closures can typically be treated like any other programming language objects, e.g. they can be stored in variables, passed to functions, and so on. 2
Here is a closure in Python:
def outsideFunc(a):
def enclosedFunc(b):
# a is "closed" in the definition of enclosedFunc
return a + b
return enclosedFunc
first = outsideFunc(4)
second = outsideFunc(2)
first (5) # returns 9
second (1) # returns 3
Implementation of closures in python is done by function calls. Here, the call to outside_func creates a binding for a that is referenced inside the function enclosedFunc. Each call to outsideFunc 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 a being used to eliminate either a global or a constant, depending on the nature of a.
This is the simplest non-trivial example using closures.
IMPORTANCE OF CLOSURES
Some uses of closures:
1. They are very usable for making code more clear and readable. And as we all know clean readable short code is a code that is easier to debug and contains fewer bugs.
For example in Java,
button.addActionListener(new ActionListener() {
@Override public void actionPerformed(ActionEvent e) {
System.out.println("Pressed");
}
});
This would be replaced (if Java had closures) with:
button.addActionListener( { System.out.println("Pressed"); } );
2. Closures are used to implement continuation-passing style, and in this manner, hide state. Constructs such as objects and control structures can thus be implemented with closures. Closures typically appear in languages in which functions are first-class values—in other words, such languages allow functions to be passed as arguments, returned from function calls, bound to variable names, etc., just like simpler types such as strings and integers.
For example, consider the following Scheme function:
Return a list of all students with at least the threshold grade.
(define (grade threshold)
(filter
(lambda (student)
(>= (student-grade student) threshold))
student-list))>
In this example, the lambda expression (lambda (student) (>= (student-grade student) threshold)) appears within the function grade. When the lambda expression is evaluated, a closure consisting of the code for the lambda expression and a reference to the threshold variable are created .The reference is a free variable inside the lambda expression.
The closure is then passed to the filter function, which calls it repeatedly to determine which books are to be added to the result list and which are to be discarded. Because the closure itself has a reference to threshold, it can use that variable each time filter calls it. The function filter itself might be defined in a completely separate file.
Here is the same example rewritten in JavaScript, another popular language with support for closures:
// Return a list of all books with at least 'threshold' copies sold.
function bestStudents(threshold) {
return studentList.filter(
function (student) { return student.grade >= threshold; }
);
}
The function keyword is used here instead of lambda, and an Array.filter method[10] instead of a global filter function.
3. Using Closures For Privacy:
With closures, you can easily have private members that are shielded from the outside world:
(function(higherLevelFunc){
function myPrivateDisplayFunction(name) {
return name;
}
higherLevelFunc.display = higherLevelFunc(name) {
console.log(myPrivateDisplayFunction(name));
}
})(window);
In this way private members can be protected from the outside world
At the top level, the function object is an anonymous function:
(function(higherLevelFunc){
})(window);
This anonymous function can be called right away . Its passed to a global context (window in this case) so the public function can be “exported” , but inner details are hidden. Because the function myPrivateDisplayFunction is a nested function, it exists only within the scope of the closure; so it can be used anywhere inside this scope and not elsewhere JavaScript will hold a reference to our private function for use inside the multiply function, but myPrivateMultiplyFunction cannot be accessed outside of the closure. Let’s try this out:
display("Cheng") // => Cheng
myPrivateDisplayFunction("Cheng") // => ReferenceError: myPrivateDisplayFunction is not defined
The closure has allowed us to define a function for private use, while still allowing us to control what the rest of the world sees.
4. Because closures delay evaluation i.e., they do not "do" anything until they are called so they can be used to define control structures. For example,all Smalltalk's standard control structures, including branches (if/then/else) and loops (while and for), are defined using objects whose methods accept closures. Users can easily define their own control structures also. In languages that allow assignment, multiple functions can be produced that close over the same environment, enabling them to communicate privately by altering that environment.
CLOSURES IN DYNAMICALLY TYPED LANGUAGES
The following are examples of closure usage in some of the dynamically typed languages.
Perl
The following is a make_adder() function, in which the returned anonymous function contains a reference to a lexical variable outside the scope of that function itself.
sub multiplier {
my $multiply = product;
return sub { product * $multiply };
}
$func1 = multiplier(20);
$func2 = multiplier(555);
Now &$func1($n) is always 20 times whatever $n you pass in, whereas &$func2($n) is always 555 times whatever $n you pass in. The $multiply in the closure sticks around. 11
Ruby
In Ruby, closures are supported through procs and lambdas. These constructs are very similar, but there are some subtle differences.
class StudentGrade
def initialize(grade)
@grade = grade
end
def printGrade(name)
lambda {puts "The student #{@name}'s grade is : #{@grade} "}
end
end
def caller(closureVariable)
closureVariable.call
end
obj1 = StudentGrade.new('A')
closureCall = obj1.printGrade("Matt")
caller(closureCall)
Upon execution,get the following output:
The student Matt's grade is A
The printGrade function creates a closure, using the lambda construct, and then returns it. The closure is assigned to a variable, closureCall which is passed to another function caller, which then calls the closure. In this way a closure can be passed around.
When we called the closure, both the variables name and grade were out of scope in the rest of the program. But when it is called ,they are still in scope as the closure retained the state of these variables
CLOSURES IN STATICALLY TYPED LANGUAGES
While neither Java nor C++ support higher order functions directly, both provide mechanisms for mimicking their behavior. Java's anonymous classes allow a function to be bundled with an object that can be treated much as a higher order function can. It can be bound to variables, passed to other functions as an argument, and can be returned as the result of a function. However, the function itself is named and thus cannot be treated in a generic fashion as true higher order functions can. C++ similarly provides partial support for higher order functions using function objects (or "functors"), and add the further benefit that the function call operator may be overloaded so that functors may be treated generically. Neither C++ nor Java, however, provides any support for lexical closures.
C
The code below, written in C, implements the call unarySumFactory to produce unary sums. C does not have syntactic support for closures. Nevertheless, we can implement closures by combining high-order function calls with dynamic heap allocation. 13
#include <stdio.h>
#include <stdlib.h>
typedef struct struct_free_variables_unarySum {
int x;
} FREE_VARIABLES_unarySum;
typedef struct {
FREE_VARIABLES_unarySum* t;
int (*f)(FREE_VARIABLES_unarySum* t, int x);
} CLOSURE_unarySum;
int unarySum(FREE_VARIABLES_unarySum* t, int y) {
return y + t->x;
};
void* unarySumFactory(int x) {
CLOSURE_unarySum* c = (CLOSURE_unarySum*) malloc (sizeof(CLOSURE_unarySum));
c->t = (FREE_VARIABLES_unarySum*) malloc (sizeof(FREE_VARIABLES_unarySum));
c->t->x = x;
c->f = &unarySum;
return c;
}
int test(int n) {
CLOSURE_unarySum* c = unarySumFactory(2);
int retVal = c->f(c->t, n);
free(c->t);
free(c);
return retVal;
}
int main(int argc, char** argv) {
printf("%d\n", test(argc));
return 0;
}
Java
The following is a code in Java programming without closures
public interface Block<T> {
void invoke(T arg);
}
public class Utils {
public static <T> void forEach(Iterable<T> seq, Block<T> fct) {
for (T elm : seq)
fct.invoke(elm);
}
}
public class Test {
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(1,2,3);
Block<Integer> print = new Block<Integer>() {
public void invoke(Integer arg) {
System.out.println(arg);
}
};
Utils.forEach(nums,print);
}
}
The example is admittedly contrived and extremely simple, but consider it: how often in Java do you find yourself implementing an interface and passing the implementation to a method for execution? We can think of three immediate examples:
Runnable and Callable, which we pass to threads or thread pools for asynchronous execution. Callback interfaces such as ActionListener, which we register for future execution in case a certain event occurs. Comparator, which we pass to a TreeMap for maintaining its sorting order.
In all these cases we use an interface, providing some functionality as an implementation of the interface. We then pass the functionality to a method for immediate or delayed, synchronous or asynchronous execution. Closures would simplify this process by allowing a more concise syntax, thereby eliminating some of Java's verbosity. Beyond allowing more concise and readable Java source code, closures would add some functionality completely new to Java, such as custom control structures.
Challenges due to lack of closures in Statically typed languages
Consider an example, given a list of employee objects and a list of those employees who are managers is to be created, which can be determined with an IsManager property.
Using C#, it probably would be written like this
public static IList Managers(IList emps)
{
IList result = new ArrayList();
foreach(Employee e in emps)
if (e.IsManager) result.Add(e);
return result;
}
In a language that has Closures, for example, Ruby, it would be written as,
def managers(emps)
return emps.select {|e| e.isManager}
end
Essentially select is a method defined on the Ruby collection class. It takes a block of code, a closure, as an argument. Select iterates through the input array, executes the block of code with each element, and returns an array of those elements for which the block evaluated as true.
The workaround in C could be using a function pointer; in Java with an anonymous inner class; and with a delegate in C#. These mechanisms are similar to closures, but there are two telling differences.
The first difference is closures can refer to variables visible at the time they were defined. Consider this method,
def highPaid(emps)
threshold = 150
return emps.select {|e| e.salary > threshold}
end
Here the code in the select block is referring to a local variable defined in the enclosing method. Many of the alternatives to closures in languages that don't have real closures can't do that. 15
Consider this function,
def paidMore(amount)
return Proc.new {|e| e.salary > amount}
end
This function returns a closure, indeed it returns a closure whose behavior depends on the argument sent into it.
highPaid = paidMore(150)
The variable highPaid contains a block of code (called a Proc in Ruby) that will return whether a tested object has a salary greater than 150.
john = Employee.new john.salary = 200 print highPaid.call(john)
REFERENCES
- Sussman and Steele. "Scheme: An interpreter for extended lambda calculus". "... a data structure containing a lambda expression, and an environment to be used when that lambda expression is applied to arguments." (Wikisource)
- Wikipedia: Closure (computer science)
- Joe Morrison: Brief introduction to four programming language concepts
- Understanding the closures debate Does Java need closures? Three proposals compared By Klaus Kreft and Angelika Langer, JavaWorld.com
- perlfaq7 - General Perl Language Issues/ What's a closure?
- Alan Skorkin: Closures – A Simple Explanation (Using Ruby)
- Wikipedia: Introduction to Programming Languages/Closures
- Voegele.com/Programmer’s Corner/Programming Language Comparison
- Martin Fowler’s Bliki - Closure