CSC/ECE 517 Fall 2011/ch1 1c cm

Introduction

high-level overview, who we are trying to target

Closures vs. Methods

introduction of the battle of functional versus object oriented history of the closures with scheme and future languages history of OO methods with C++ and other languages

Summary Table

graphical breakdown of the two and the features we think are important for each

Closures

A closure is a block of executable code together with a reference to the local variables from the environment in which it was created. The local variables are captured by the closure, and their lifetime is extended throughout the lifetime of the closure. Closures can be created by defining a function within the body of another function as the following example illustrates. Note that the scope of the parameter n is limited to the inside of the addGen function. However, because addGen returns a closure, that closure has access to n whenever it is evoked.

An example of a function returning a closure in JavaScript.

function addGen(n) {
    return function (x) {
        return x + n;
    };
}

var add5 = addGen(5);
var add10 = addGen(10);

alert(add5(6));     // 11
alert(add10(6));    // 16

Here is the same example in C#.

public Func<int, int> addGen(int n)
{
    return x => x + n;
}

var add5 = addGen(5);
var add10 = addGen(10);

Console.WriteLine(add5(6));    // 11
Console.WriteLine(add10(6));   // 16

And again in Ruby

def addGen(n)
    Proc.new { |x| x + n }
end

add5 = addGen(5)
add10 = addGen(10)

puts add5(6)      # 11
puts add10(6)     # 16

First-class functions

Closures are closely related to first-class functions, because typically a closure is a first-class function. A first-class function is a function that can appear anywhere in a program that other first-class values (such as a number or a string) can appear. Namely, a first-class function can be assigned to a variable, passed as an argument to another function, and returned as the return value from a function. Closures are first-class functions that capture the local variables (or free variables) from the site of their definition.

Execution-time environment contains free variables

closures capture variables referenced at the time they are created and the lifetime of those captured variables is extended to at least as long as the lifetime of the closure

function multipleClosures() {
    var i = 0;
    return [
        function () { return ++i; },
        function () { return --i; }
    ];
}

var closures = multipleClosures();

alert(closures[0]());    // 1
alert(closures[0]());    // 2
alert(closures[1]());    // 1

public Func<int>[] multipleClosures()
{
    int i = 0;
    return new Func<int>[] { () => ++i, () => --i };
}

var closures = multipleClosures();

Console.WriteLine(closures[0]());    // 1
Console.WriteLine(closures[0]());    // 2
Console.WriteLine(closures[1]());    // 1

def multipleClosures
i = 0
[ Proc.new { i = i + 1 }, Proc.new { i = i - 1 } ]
end

closures = multipleClosures

puts closures[0].call    # 1
puts closures[0].call    # 2
puts closures[1].call    # 1

Methods

“Object orientation is a boon because it allows a designer to hide behind the scenic walls of encapsulation such software eyes as: convoluted data structures, complex combinatorial logic, elaborate relationships between procedure and data, [and] sophisticated algorithms” [pg 65, Fun]

Object-oriented programming dates back to at least the middle 1960's. One of the fundamental principals of objects is the notion of encapsulation. One of the earliest descriptions of the methodology, dates back to a 1966 paper describing the SIMULA, a language designed to ease simulation of large systems. The SIMULA language used classes to encapsulate coupled procedures and data into an object, “an object is a self-contained program (block instance) having its own local data and actions defined by a 'class declaration'” [pg 6, Simula]. This 50 year-old concept of fields and procedures is central to the design of today's object-oriented languages such as Smalltalk, Java and C++. The method will be defined using the following criteria:

• An object as first-class data which allows binding of

1. finite set of static or instance data (commonly referred to as fields) created by the programmer which hold the state of the object
2. procedures or actions modifying the data to change the state of the object
3. an ability to access methods across objects (data sharing)

Instance or static class functions

Our definition of a method requires functions which can be bound to a first-class object. All object-oriented languages provide this construct. We can create objects and pass those objects around to be executed by other objects or in the global environment.

C++

class InstanceFunction
{
	public:
		void doSomething() { return; }
};
InstanceFunction if;
InstanceFunction *pif = &if;
pif->doSomething();

It should be noted that the instance or static class functions need not be created at compile time if the language supports dynamic, first-class functions.

Javascript

var instanceFunction = new Object();
instanceFunction.doSomething = new function() { return; }
instanceFunction.doSomething();

While the function in Javascript is a first-class function, the scope over which the method operates is still localized to the object over which it was added. The first-class, dynamic function is not a closure.

Execution-time environment contains instance or static variables

The second point of the method definition is that the we can bind static or instance data to our first-class data object. All object-oriented language also provide this construct.

C++

class InstanceData
{
	public:
		InstanceData() : mSomeData(0) {}
		unsigned mSomeData;
};
InstanceData id;
InstanceData *pid = &id;
printf(“%d\n”, pid->mSomeData);

Again it is worth noting that the data need not be static at compile time it only must exist in the context of the object for which it is defined.

Javascript

var instanceData = new Object();
instanceData.mSomeData = 1;
echo instanceData.mSomeData;

The Javascript example dynamically adds data to the object. The data is available within the context of the object and it's scope is limited to the object. When the object goes out of scope, the data also goes out of scope.