Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-23T21:41:15Z

Sskanitk: /* Coding Example - Adapter Pattern in Ruby */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists of numerous examples. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
==='''''1. SINGLETON PATTERN'''''===
====Definition====
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Applications====
# You might want to have only one Window Manager to manage all your open windows in your system.
# Logging, where it provides a global logging access point in all the application components without being necessary to create an object each time a logging operations is performed. <ref>[http://www.oodesign.com/singleton-pattern.html Logger Classes]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

==='''''2. ADAPTER PATTERN'''''===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. - Head First Design Patterns <ref>[Freeman, Elisabeth, Bert Bates, and Kathy Sierra. Head First Design Patterns. Web.]</ref>

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

[[Image:Adapter kp1.png]]

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not based on if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

==='''''3. COMMAND PATTERN'''''===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns <ref>[Freeman, Elisabeth, Bert Bates, and Kathy Sierra. Head First Design Patterns. Web.]</ref>

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

==='''''4. STRATEGY PATTERN'''''===
====Definition====
"In computer programming, the strategy pattern is a design pattern, whereby algorithms can be selected at runtime. Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it." - Wikipedia <ref>[http://en.wikipedia.org/wiki/Strategy_pattern Stratey Pattern Wikipedia]</ref>

====Example code for Strategy pattern====
Here we will see how strategy pattern can be used to sort a given list of real numbers using either BubbleSort() or QuickSort().

Below is an interface to describe the individual algorithms.
<nowiki>
public interface SortingInterface {
public void sort(double[] list);
}
</nowiki>

Now implement both the Quicksort & Bubblesort strategies.
<nowiki>
public class QuickSort implements SortingInterface {
//QuickSort will implement the sort() with the quicksort version.
public void sort(double[] list) {
//Do quick sort here
}
}

public class BubbleSort implements SortingInterface {

//BubbleSort will implement the sort() with the bubblesort version.
public void sort(double[] list) {

//Do bubble sort here
}
}
</nowiki>

Now define a Strategy context that maintains a reference to a Strategy object(Bubblesort or Quicksort) and forwards client requests to that strategy.

<nowiki>
public class Context {
private SortingInterface algorithm = null;

public void sortGivenList(double[] list) {
algorithm.sort(list);
}

//Getter method for algorithm
public SortingInterface getAlgorithm() {
return algorithm;
}

//Setter method for algorithm
public void setAlgorithm(SortingInterface algorithm) {
this.algorithm = algorithm;
}

}
</nowiki>

Finally, the client picks one of the available strategies(Quicksort or Bubblesort) in the context and sorts the List according to that strategy as shown below.
<nowiki>
public class Client {

public static void main(String[] args) {

//Here is the List
double[] list = {1,2.4,7.9,3.2,1.2,0.2,10.2,22.5,19.6,14,12,16,17};

//Now define the Context
Context context = new Context();

//Now pick your strategy i.e. Quicksort or Bubblesort
context.setAlgorithm(new BubbleSort());

///Now, sort it using the strategy you picked
context.sortGivenList(list);

}
</nowiki>

====Applications====
*Sorting a list: where the strategy can be to choose the sorting algorithm itself (QuickSort, HeapSort, etc.) at runtime depending on the input data. <ref>[http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Sorting a llist using Strategy pattern]</ref>
*[http://en.wikipedia.org/wiki/Layout_manager Layout Managers] in UI toolkits: where you can decide at runtime what layout is to be chosen for the GUI to be displayed.<ref>[http://stackoverflow.com/questions/370258/real-world-example-of-the-strategy-pattern Strategy Pattern Real world examples]</ref>

====Differences between Command and Strategy Pattern====
*A Command Pattern encapsulates a single action/algorithm whereas the Strategy pattern provides us with a number of actions/algorithms which can be selected based on a number of factors.
*A Command Pattern object has a single method but with a generic signature whereas Strategy pattern may have as many different methods provided.

==Design Patterns at a Glance==

{| class="wikitable" border="1"

|-
! Design Patterns
! Singleton
! Adapter
! Command
! Strategy

|-
! Purpose
| To ensure a class has only one instance, and also to provide a global point of access to it
| To convert the interface of a class into another interface the clients expects
| To encapsulate method invocations so as to decouple caller from the implementation details
| To perform a bunch of different things to do, based on the situation/context

|-
! Advantages
| Sane usage of global namespace by avoiding unnecessary global variables and providing on-demand (lazy) instantiations.
| It lets classes work together that could not otherwise because of incompatible interfaces.
| It allows one to decouple the requester of an action from the object that actually performs the action.
| It lets the algorithms vary independently from clients that use those.

|-
! Disadvantages
| Introduces global state into system and complicates unit testing.
| Adapter has to implement the entire target interface. Selective functionality implementation is not an option.
| Having Command objects specific to each action ends up cluttering the design, especially in the context of MVC architectures <ref>[http://www.codeproject.com/KB/architecture/commandpatterndemo.aspx Disadvantage of Command Pattern]</ref>
| Increases the number of objects and all algorithms use the same interface. <ref> [https://docs.google.com/a/ncsu.edu/viewer?a=v&q=cache:UGImuHnhO8MJ:www.cs.toronto.edu/~arnold/407/06s/lectures/studentPresentations/stateStrategy/state_strat_pres.ppt+disadvantages+of+strategy+pattern&hl=en&gl=us&pid=bl&srcid=ADGEEShbX8h_8wQ7PkIoXMKwXjPgISI7dduhY-HrO8fUV8lntQw0RYYWQ-eG_hLAxTT3pjUj5j5Dj8F7-baC3D-C6Znv_YTujBdB_E6-WkZ9KMe2jWXGtZgeRtMcwEJtpqN8JNOC9itc&sig=AHIEtbSP_rpR12IcGL1KyQAhi0PGeUQqrQ&pli=1 Disadvantages of Strategy Pattern]</ref>

|}

==Conclusion==
*The objective of the Singleton pattern as defined in Design Patterns is to "ensure a class has only one instance, and also to provide a global point of access to it".<ref>[http://social.msdn.microsoft.com/forums/en-US/architecturegeneral/thread/b746fa87-5e52-4474-b5f7-688c7f14823c Why or Why not Singleton]</ref>
* The Adapter Pattern converts the interface of a class into another interface the clients expects. This decouples the client and adaptee and allows them to work together.
* Command Pattern encapsulates method invocations, by which pieces of computation are crystallized, hence the object invoking the computation doesn't need to worry about how things are done.
*Strategy pattern should be used when you have a bunch of different things to do, based on the situation/context.

==References==
<references/>

==External Resources==
*Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Web.
*Effective Java 2nd Edition By Joshua Bloch

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-23T21:39:02Z

Sskanitk: /* Examples */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists of numerous examples. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
==='''''1. SINGLETON PATTERN'''''===
====Definition====
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Applications====
# You might want to have only one Window Manager to manage all your open windows in your system.
# Logging, where it provides a global logging access point in all the application components without being necessary to create an object each time a logging operations is performed. <ref>[http://www.oodesign.com/singleton-pattern.html Logger Classes]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

==='''''2. ADAPTER PATTERN'''''===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. - Head First Design Patterns <ref>[Freeman, Elisabeth, Bert Bates, and Kathy Sierra. Head First Design Patterns. Web.]</ref>

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

[[Image:Adapter kp1.png]]

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

==='''''3. COMMAND PATTERN'''''===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns <ref>[Freeman, Elisabeth, Bert Bates, and Kathy Sierra. Head First Design Patterns. Web.]</ref>

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

==='''''4. STRATEGY PATTERN'''''===
====Definition====
"In computer programming, the strategy pattern is a design pattern, whereby algorithms can be selected at runtime. Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it." - Wikipedia <ref>[http://en.wikipedia.org/wiki/Strategy_pattern Stratey Pattern Wikipedia]</ref>

====Example code for Strategy pattern====
Here we will see how strategy pattern can be used to sort a given list of real numbers using either BubbleSort() or QuickSort().

Below is an interface to describe the individual algorithms.
<nowiki>
public interface SortingInterface {
public void sort(double[] list);
}
</nowiki>

Now implement both the Quicksort & Bubblesort strategies.
<nowiki>
public class QuickSort implements SortingInterface {
//QuickSort will implement the sort() with the quicksort version.
public void sort(double[] list) {
//Do quick sort here
}
}

public class BubbleSort implements SortingInterface {

//BubbleSort will implement the sort() with the bubblesort version.
public void sort(double[] list) {

//Do bubble sort here
}
}
</nowiki>

Now define a Strategy context that maintains a reference to a Strategy object(Bubblesort or Quicksort) and forwards client requests to that strategy.

<nowiki>
public class Context {
private SortingInterface algorithm = null;

public void sortGivenList(double[] list) {
algorithm.sort(list);
}

//Getter method for algorithm
public SortingInterface getAlgorithm() {
return algorithm;
}

//Setter method for algorithm
public void setAlgorithm(SortingInterface algorithm) {
this.algorithm = algorithm;
}

}
</nowiki>

Finally, the client picks one of the available strategies(Quicksort or Bubblesort) in the context and sorts the List according to that strategy as shown below.
<nowiki>
public class Client {

public static void main(String[] args) {

//Here is the List
double[] list = {1,2.4,7.9,3.2,1.2,0.2,10.2,22.5,19.6,14,12,16,17};

//Now define the Context
Context context = new Context();

//Now pick your strategy i.e. Quicksort or Bubblesort
context.setAlgorithm(new BubbleSort());

///Now, sort it using the strategy you picked
context.sortGivenList(list);

}
</nowiki>

====Applications====
*Sorting a list: where the strategy can be to choose the sorting algorithm itself (QuickSort, HeapSort, etc.) at runtime depending on the input data. <ref>[http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Sorting a llist using Strategy pattern]</ref>
*[http://en.wikipedia.org/wiki/Layout_manager Layout Managers] in UI toolkits: where you can decide at runtime what layout is to be chosen for the GUI to be displayed.<ref>[http://stackoverflow.com/questions/370258/real-world-example-of-the-strategy-pattern Strategy Pattern Real world examples]</ref>

====Differences between Command and Strategy Pattern====
*A Command Pattern encapsulates a single action/algorithm whereas the Strategy pattern provides us with a number of actions/algorithms which can be selected based on a number of factors.
*A Command Pattern object has a single method but with a generic signature whereas Strategy pattern may have as many different methods provided.

==Design Patterns at a Glance==

{| class="wikitable" border="1"

|-
! Design Patterns
! Singleton
! Adapter
! Command
! Strategy

|-
! Purpose
| To ensure a class has only one instance, and also to provide a global point of access to it
| To convert the interface of a class into another interface the clients expects
| To encapsulate method invocations so as to decouple caller from the implementation details
| To perform a bunch of different things to do, based on the situation/context

|-
! Advantages
| Sane usage of global namespace by avoiding unnecessary global variables and providing on-demand (lazy) instantiations.
| It lets classes work together that could not otherwise because of incompatible interfaces.
| It allows one to decouple the requester of an action from the object that actually performs the action.
| It lets the algorithms vary independently from clients that use those.

|-
! Disadvantages
| Introduces global state into system and complicates unit testing.
| Adapter has to implement the entire target interface. Selective functionality implementation is not an option.
| Having Command objects specific to each action ends up cluttering the design, especially in the context of MVC architectures <ref>[http://www.codeproject.com/KB/architecture/commandpatterndemo.aspx Disadvantage of Command Pattern]</ref>
| Increases the number of objects and all algorithms use the same interface. <ref> [https://docs.google.com/a/ncsu.edu/viewer?a=v&q=cache:UGImuHnhO8MJ:www.cs.toronto.edu/~arnold/407/06s/lectures/studentPresentations/stateStrategy/state_strat_pres.ppt+disadvantages+of+strategy+pattern&hl=en&gl=us&pid=bl&srcid=ADGEEShbX8h_8wQ7PkIoXMKwXjPgISI7dduhY-HrO8fUV8lntQw0RYYWQ-eG_hLAxTT3pjUj5j5Dj8F7-baC3D-C6Znv_YTujBdB_E6-WkZ9KMe2jWXGtZgeRtMcwEJtpqN8JNOC9itc&sig=AHIEtbSP_rpR12IcGL1KyQAhi0PGeUQqrQ&pli=1 Disadvantages of Strategy Pattern]</ref>

|}

==Conclusion==
*The objective of the Singleton pattern as defined in Design Patterns is to "ensure a class has only one instance, and also to provide a global point of access to it".<ref>[http://social.msdn.microsoft.com/forums/en-US/architecturegeneral/thread/b746fa87-5e52-4474-b5f7-688c7f14823c Why or Why not Singleton]</ref>
* The Adapter Pattern converts the interface of a class into another interface the clients expects. This decouples the client and adaptee and allows them to work together.
* Command Pattern encapsulates method invocations, by which pieces of computation are crystallized, hence the object invoking the computation doesn't need to worry about how things are done.
*Strategy pattern should be used when you have a bunch of different things to do, based on the situation/context.

==References==
<references/>

==External Resources==
*Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Web.
*Effective Java 2nd Edition By Joshua Bloch

Http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T19:40:35Z

Sskanitk: /* Design Patterns at a Glance */

This page has been moved to [http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch4_4h_kp http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch4_4h_kp]

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T19:36:10Z

Sskanitk:

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists numerous examples inturn. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
==='''''1. SINGLETON PATTERN'''''===
====Definition====
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Applications====
# You might want to have only one Window Manager to manage all your open windows in your system.
# Logging, where it provides a global logging access point in all the application components without being necessary to create an object each time a logging operations is performed. <ref>[http://www.oodesign.com/singleton-pattern.html Logger Classes]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

==='''''2. ADAPTER PATTERN'''''===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
- Head First Design Patterns

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

[[Image:Adapter kp1.png]]

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

==='''''3. COMMAND PATTERN'''''===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

==='''''4. STRATEGY PATTERN'''''===
====Definition====
"In computer programming, the strategy pattern is a design pattern, whereby algorithms can be selected at runtime. Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it." - Wikipedia <ref>[http://en.wikipedia.org/wiki/Strategy_pattern Stratey Pattern Wikipedia]</ref>

====Example code for Strategy pattern====
Here we will see how strategy pattern can be used to sort a given list of real numbers using either BubbleSort() or QuickSort().

Below is an interface to describe the individual algorithms.
<nowiki>
public interface SortingInterface {
public void sort(double[] list);
}
</nowiki>

Now implement both the Quicksort & Bubblesort strategies.
<nowiki>
public class QuickSort implements SortingInterface {
//QuickSort will implement the sort() with the quicksort version.
public void sort(double[] list) {
//Do quick sort here
}
}

public class BubbleSort implements SortingInterface {

//BubbleSort will implement the sort() with the bubblesort version.
public void sort(double[] list) {

//Do bubble sort here
}
}
</nowiki>

Now define a Strategy context that maintains a reference to a Strategy object(Bubblesort or Quicksort) and forwards client requests to that strategy.

<nowiki>
public class Context {
private SortingInterface algorithm = null;

public void sortGivenList(double[] list) {
algorithm.sort(list);
}

//Getter method for algorithm
public SortingInterface getAlgorithm() {
return algorithm;
}

//Setter method for algorithm
public void setAlgorithm(SortingInterface algorithm) {
this.algorithm = algorithm;
}

}
</nowiki>

Finally, the client picks one of the available strategies(Quicksort or Bubblesort) in the context and sorts the List according to that strategy as shown below.
<nowiki>
public class Client {

public static void main(String[] args) {

//Here is the List
double[] list = {1,2.4,7.9,3.2,1.2,0.2,10.2,22.5,19.6,14,12,16,17};

//Now define the Context
Context context = new Context();

//Now pick your strategy i.e. Quicksort or Bubblesort
context.setAlgorithm(new BubbleSort());

///Now, sort it using the strategy you picked
context.sortGivenList(list);

}
</nowiki>

====Applications====
*Sorting a list: where the strategy can be to choose the sorting algorithm itself (QuickSort, HeapSort, etc.) at runtime depending on the input data. <ref>[http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Sorting a llist using Strategy pattern]</ref>
*[http://en.wikipedia.org/wiki/Layout_manager Layout Managers] in UI toolkits: where you can decide at runtime what layout is to be chosen for the GUI to be displayed.<ref>[http://stackoverflow.com/questions/370258/real-world-example-of-the-strategy-pattern Strategy Pattern Real world examples]</ref>

====Differences between Command and Strategy Pattern====
*A Command Pattern encapsulates a single action/algorithm whereas the Strategy pattern provides us with a number of actions/algorithms which can be selected based on a number of factors.
*A Command Pattern object has a single method but with a generic signature whereas Strategy pattern may have as many different methods provided.

==Design Patterns at a Glance==

{| class="wikitable" border="1"

|-
! Design Patterns
! Singleton
! Adapter
! Command
! Strategy

|-
! Purpose
| To ensure a class has only one instance, and also to provide a global point of access to it
| To convert the interface of a class into another interface the clients expects
| To encapsulate method invocations so as to decouple caller from the implementation details
| To perform a bunch of different things to do, based on the situation/context

|-
! Advantages
| Sane usage of global namespace by avoiding unnecessary global variables and providing on-demand (lazy) instantiations.
| It lets classes work together that could not otherwise because of incompatible interfaces.
| It allows one to decouple the requester of an action from the object that actually performs the action.
| It lets the algorithms vary independently from clients that use those.

|-
! Disadvantages
| Introduces global state into system and complicates unit testing.
| Adapter has to implement the entire target interface. Selective functionality implementation is not an option.
| Having Command objects specific to each action ends up cluttering the design, especially in the context of MVC architectures <ref>[http://www.codeproject.com/KB/architecture/commandpatterndemo.aspx Disadvantage of Command Pattern]</ref>
| Increases the number of objects and all algorithms use the same interface. <ref> [https://docs.google.com/a/ncsu.edu/viewer?a=v&q=cache:UGImuHnhO8MJ:www.cs.toronto.edu/~arnold/407/06s/lectures/studentPresentations/stateStrategy/state_strat_pres.ppt+disadvantages+of+strategy+pattern&hl=en&gl=us&pid=bl&srcid=ADGEEShbX8h_8wQ7PkIoXMKwXjPgISI7dduhY-HrO8fUV8lntQw0RYYWQ-eG_hLAxTT3pjUj5j5Dj8F7-baC3D-C6Znv_YTujBdB_E6-WkZ9KMe2jWXGtZgeRtMcwEJtpqN8JNOC9itc&sig=AHIEtbSP_rpR12IcGL1KyQAhi0PGeUQqrQ&pli=1 Disadvantages of Strategy Pattern]</ref>

|}

==Conclusion==
*The objective of the Singleton pattern as defined in Design Patterns is to "ensure a class has only one instance, and also to provide a global point of access to it".<ref>[http://social.msdn.microsoft.com/forums/en-US/architecturegeneral/thread/b746fa87-5e52-4474-b5f7-688c7f14823c Why or Why not Singleton]</ref>
* The Adapter Pattern converts the interface of a class into another interface the clients expects. This decouples the client and adaptee and allows them to work together.
* Command Pattern encapsulates method invocations, by which pieces of computation are crystallized, hence the object invoking the computation doesn't need to worry about how things are done.
*Strategy pattern should be used when you have a bunch of different things to do, based on the situation/context.

==References==
<references/>
* Head First Design Patterns By Elisabeth Freeman (Author), Eric Freeman (Author), Bert Bates (Author), Kathy Sierra (Author)
* Design Patterns: Elements of Reusable Object-Oriented Software By Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides
* Effective Java 2nd Edition By Joshua Bloch

Http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T19:34:12Z

Sskanitk:

This page has been moved to [http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch4_4h_kp http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch4_4h_kp]

==Design Patterns at a Glance==

{| class="wikitable" border="1"

|-
! Design Patterns
! Singleton
! Adapter
! Command
! Strategy

|-
! Purpose
| To ensure a class has only one instance, and also to provide a global point of access to it
| To convert the interface of a class into another interface the clients expects
| To encapsulate method invocations so as to decouple caller from the implementation details
| To perform a bunch of different things to do, based on the situation/context

|-
! Advantages
| Sane usage of global namespace by avoiding unnecessary global variables and providing on-demand (lazy) instantiations.
| It lets classes work together that could not otherwise because of incompatible interfaces.
| It allows one to decouple the requester of an action from the object that actually performs the action.
| It lets the algorithms vary independently from clients that use those.

|-
! Disadvantages
| Introduces global state into system and complicates unit testing.
| Adapter has to implement the entire target interface. Selective functionality implementation is not an option.
| Having Command objects specific to each action ends up cluttering the design, especially in the context of MVC architectures <ref>[http://www.codeproject.com/KB/architecture/commandpatterndemo.aspx]</ref>
| Increases the number of objects and all algorithms use the same interface. <ref> [www.cs.toronto.edu/~arnold/407/.../stateStrategy/state_strat_pres.ppt] </ref>

|}

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T04:58:37Z

Sskanitk: /* References */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists numerous examples inturn. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
==='''''1. SINGLETON PATTERN'''''===
====Definition====
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Applications====
# You might want to have only one Window Manager to manage all your open windows in your system.
# Logging, where it provides a global logging access point in all the application components without being necessary to create an object each time a logging operations is performed. <ref>[http://www.oodesign.com/singleton-pattern.html Logger Classes]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

==='''''2. ADAPTER PATTERN'''''===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
- Head First Design Patterns

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

[[Image:Adapter kp1.png]]

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

==='''''3. COMMAND PATTERN'''''===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

==='''''4. STRATEGY PATTERN'''''===
====Definition====
"In computer programming, the strategy pattern is a design pattern, whereby algorithms can be selected at runtime. Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it." - Wikipedia <ref>[http://en.wikipedia.org/wiki/Strategy_pattern Stratey Pattern Wikipedia]</ref>

====Example code for Strategy pattern====
Here we will see how strategy pattern can be used to sort a given list of real numbers using either BubbleSort() or QuickSort().

Below is an interface to describe the individual algorithms.
<nowiki>
public interface SortingInterface {
public void sort(double[] list);
}
</nowiki>

Now implement both the Quicksort & Bubblesort strategies.
<nowiki>
public class QuickSort implements SortingInterface {
//QuickSort will implement the sort() with the quicksort version.
public void sort(double[] list) {
//Do quick sort here
}
}

public class BubbleSort implements SortingInterface {

//BubbleSort will implement the sort() with the bubblesort version.
public void sort(double[] list) {

//Do bubble sort here
}
}
</nowiki>

Now define a Strategy context that maintains a reference to a Strategy object(Bubblesort or Quicksort) and forwards client requests to that strategy.

<nowiki>
public class Context {
private SortingInterface algorithm = null;

public void sortGivenList(double[] list) {
algorithm.sort(list);
}

//Getter method for algorithm
public SortingInterface getAlgorithm() {
return algorithm;
}

//Setter method for algorithm
public void setAlgorithm(SortingInterface algorithm) {
this.algorithm = algorithm;
}

}
</nowiki>

Finally, the client picks one of the available strategies(Quicksort or Bubblesort) in the context and sorts the List according to that strategy as shown below.
<nowiki>
public class Client {

public static void main(String[] args) {

//Here is the List
double[] list = {1,2.4,7.9,3.2,1.2,0.2,10.2,22.5,19.6,14,12,16,17};

//Now define the Context
Context context = new Context();

//Now pick your strategy i.e. Quicksort or Bubblesort
context.setAlgorithm(new BubbleSort());

///Now, sort it using the strategy you picked
context.sortGivenList(list);

}
</nowiki>

====Applications====
*Sorting a list: where the strategy can be to choose the sorting algorithm itself (QuickSort, HeapSort, etc.) at runtime depending on the input data. <ref>[http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Sorting a llist using Strategy pattern]</ref>
*[http://en.wikipedia.org/wiki/Layout_manager Layout Managers] in UI toolkits: where you can decide at runtime what layout is to be chosen for the GUI to be displayed.<ref>[http://stackoverflow.com/questions/370258/real-world-example-of-the-strategy-pattern Strategy Pattern Real world examples]</ref>

====Differences between Command and Strategy Pattern====
*A Command Pattern encapsulates a single action/algorithm whereas the Strategy pattern provides us with a number of actions/algorithms which can be selected based on a number of factors.
*A Command Pattern object has a single method but with a generic signature whereas Strategy pattern may have as many different methods provided.

==Conclusion==
*The objective of the Singleton pattern as defined in Design Patterns is to "ensure a class has only one instance, and also to provide a global point of access to it".<ref>[http://social.msdn.microsoft.com/forums/en-US/architecturegeneral/thread/b746fa87-5e52-4474-b5f7-688c7f14823c Why or Why not Singleton]</ref>
* The Adapter Pattern converts the interface of a class into another interface the clients expects. This decouples the client and adaptee and allows them to work together.
* Command Pattern encapsulates method invocations, by which pieces of computation are crystallized, hence the object invoking the computation doesn't need to worry about how things are done.
*Strategy pattern should be used when you have a bunch of different things to do, based on the situation/context.

==References==
<references/>
* Head First Design Patterns By Elisabeth Freeman (Author), Eric Freeman (Author), Bert Bates (Author), Kathy Sierra (Author)
* Design Patterns: Elements of Reusable Object-Oriented Software By Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides
* Effective Java 2nd Edition By Joshua Bloch

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T04:55:44Z

Sskanitk: /* Conclusion */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists numerous examples inturn. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
==='''''1. SINGLETON PATTERN'''''===
====Definition====
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Applications====
# You might want to have only one Window Manager to manage all your open windows in your system.
# Logging, where it provides a global logging access point in all the application components without being necessary to create an object each time a logging operations is performed. <ref>[http://www.oodesign.com/singleton-pattern.html Logger Classes]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

==='''''2. ADAPTER PATTERN'''''===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
- Head First Design Patterns

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

[[Image:Adapter kp1.png]]

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

==='''''3. COMMAND PATTERN'''''===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

==='''''4. STRATEGY PATTERN'''''===
====Definition====
"In computer programming, the strategy pattern is a design pattern, whereby algorithms can be selected at runtime. Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it." - Wikipedia <ref>[http://en.wikipedia.org/wiki/Strategy_pattern Stratey Pattern Wikipedia]</ref>

====Example code for Strategy pattern====
Here we will see how strategy pattern can be used to sort a given list of real numbers using either BubbleSort() or QuickSort().

Below is an interface to describe the individual algorithms.
<nowiki>
public interface SortingInterface {
public void sort(double[] list);
}
</nowiki>

Now implement both the Quicksort & Bubblesort strategies.
<nowiki>
public class QuickSort implements SortingInterface {
//QuickSort will implement the sort() with the quicksort version.
public void sort(double[] list) {
//Do quick sort here
}
}

public class BubbleSort implements SortingInterface {

//BubbleSort will implement the sort() with the bubblesort version.
public void sort(double[] list) {

//Do bubble sort here
}
}
</nowiki>

Now define a Strategy context that maintains a reference to a Strategy object(Bubblesort or Quicksort) and forwards client requests to that strategy.

<nowiki>
public class Context {
private SortingInterface algorithm = null;

public void sortGivenList(double[] list) {
algorithm.sort(list);
}

//Getter method for algorithm
public SortingInterface getAlgorithm() {
return algorithm;
}

//Setter method for algorithm
public void setAlgorithm(SortingInterface algorithm) {
this.algorithm = algorithm;
}

}
</nowiki>

Finally, the client picks one of the available strategies(Quicksort or Bubblesort) in the context and sorts the List according to that strategy as shown below.
<nowiki>
public class Client {

public static void main(String[] args) {

//Here is the List
double[] list = {1,2.4,7.9,3.2,1.2,0.2,10.2,22.5,19.6,14,12,16,17};

//Now define the Context
Context context = new Context();

//Now pick your strategy i.e. Quicksort or Bubblesort
context.setAlgorithm(new BubbleSort());

///Now, sort it using the strategy you picked
context.sortGivenList(list);

}
</nowiki>

====Applications====
*Sorting a list: where the strategy can be to choose the sorting algorithm itself (QuickSort, HeapSort, etc.) at runtime depending on the input data. <ref>[http://java-x.blogspot.com/2006/12/implementing-strategy-pattern-in-java.html Sorting a llist using Strategy pattern]</ref>
*[http://en.wikipedia.org/wiki/Layout_manager Layout Managers] in UI toolkits: where you can decide at runtime what layout is to be chosen for the GUI to be displayed.<ref>[http://stackoverflow.com/questions/370258/real-world-example-of-the-strategy-pattern Strategy Pattern Real world examples]</ref>

====Differences between Command and Strategy Pattern====
*A Command Pattern encapsulates a single action/algorithm whereas the Strategy pattern provides us with a number of actions/algorithms which can be selected based on a number of factors.
*A Command Pattern object has a single method but with a generic signature whereas Strategy pattern may have as many different methods provided.

==Conclusion==
*The objective of the Singleton pattern as defined in Design Patterns is to "ensure a class has only one instance, and also to provide a global point of access to it".<ref>[http://social.msdn.microsoft.com/forums/en-US/architecturegeneral/thread/b746fa87-5e52-4474-b5f7-688c7f14823c Why or Why not Singleton]</ref>
* The Adapter Pattern converts the interface of a class into another interface the clients expects. This decouples the client and adaptee and allows them to work together.
* Command Pattern encapsulates method invocations, by which pieces of computation are crystallized, hence the object invoking the computation doesn't need to worry about how things are done.
*Strategy pattern should be used when you have a bunch of different things to do, based on the situation/context.

==References==
<references/>

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T03:24:08Z

Sskanitk: /* Conceptual Work-out of the Adapter Pattern */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists numerous examples inturn. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
==='''SINGLETON'''===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

===Adapter===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
- Head First Design Patterns

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

[[Image:Adapter kp1.png]]

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

===Command===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

===Strategy===

==Conclusion==

==References==
<references/>

==External Links==

File:Adapter kp1.png

2011-10-21T03:23:58Z

Sskanitk:

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T03:22:44Z

Sskanitk: /* Overview */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists numerous examples inturn. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
===Singleton===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it. Notice that the constructor is "private". So external classes, cannot instantiate the object of class "Singleton" directly. The only way to get an instance of this class is by using the getInstance() method.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() { //Notice that the constructor is private.
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

===Adapter===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
- Head First Design Patterns

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -
[[Image:Adapter kp.png]]

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

===Command===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

===Strategy===

==Conclusion==

==References==
<references/>

==External Links==

File:Adapter kp.png

2011-10-21T03:22:35Z

Sskanitk:

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T03:20:12Z

Sskanitk: /* Adapter */

==Introduction==
This wiki article discusses about some of the commonly used & easy to understand Desgin patterns[http://en.wikipedia.org/wiki/Design_pattern_(computer_science)] in the software industry. Specifically, we will be studying about the Singleton, Adapter, Command & Strategy patterns.

==Design Pattern==
===Definition===
Some of the common definitions available online are as follows.
*"In [http://en.wikipedia.org/wiki/Software_engineering software engineering], a design [http://en.wikipedia.org/wiki/Pattern pattern] is a general reusable solution to a commonly occurring problem within a given context in [http://en.wikipedia.org/wiki/Software_design software design]. A design pattern is not a finished design that can be transformed directly into [http://en.wikipedia.org/wiki/Code_(computer_programming) code]. It is a description or template for how to solve a problem that can be used in many different situations. [http://en.wikipedia.org/wiki/Object-oriented Object-oriented] design patterns typically show relationships and [http://en.wikipedia.org/wiki/Interaction interaction]s between [http://en.wikipedia.org/wiki/Class_(computer_science) class]es or [http://en.wikipedia.org/wiki/Object_(computer_science) object]s, without specifying the final application classes or objects that are involved." -Wikipedia <ref>[http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Pattern in Computer Science, Wikipedia]</ref>

*"A design pattern is a repeatable solution to a software engineering problem. Unlike most program-specific solutions, design patterns are used in many programs. Design patterns are not considered finished product; rather, they are templates that can be applied to multiple situations and can be improved over time, making a very robust software engineering tool. Because development speed is increased when using a proven prototype, developers using design pattern templates can improve coding efficiency and final product readability." -Techopedia <ref>[http://www.techopedia.com/definition/18822/design-pattern Techopedia explains Design Pattern]</ref>

In a layman's term, Design Patterns are
*descriptions of what experienced designers know.
*hints for choosing classes & methods
*higher order abstractions for program organization
*used to weigh design tradeoffs
*used to avoid limitations of implementation language. <ref>[http://norvig.com/design-patterns/ppframe.htm Design Patterns in Dynamic Languages - Peter Norvig]</ref>

===Examples===
There are various types of Design Patterns, viz [http://en.wikipedia.org/wiki/Creational_pattern creational patterns], [http://en.wikipedia.org/wiki/Structural_pattern structural patterns], and [http://en.wikipedia.org/wiki/Behavioral_pattern behavioral patterns], each of which consists numerous examples inturn. But that is not the scope of our discussion. So, let us limit ourselves to the following 4 pattern examples.
#Singleton pattern (type of Creational pattern).
#Adapter pattern (type Structural pattern).
#Command pattern (type of Behavioral pattern).
#Strategy pattern (type of Behavioral pattern).

==Case Study==
===Singleton===
[http://en.wikipedia.org/wiki/Singleton_pattern Singleton] is a design pattern which imposes a restriction on the class to instantiate exactly one object of that class.

====Implementation====
*In Java, We can create a [http://en.wikipedia.org/wiki/Thread-safe thread-safe] & [http://en.wikipedia.org/wiki/Lazy_initialization lazy version] of Singleton as follows. The comments in the code help you understand the Lazy & thread-safe aspect of it.
<nowiki>
public class Singleton {
private static Singleton instance;

private Singleton() {
//Do nothing. Initialize the object only when the first time getInstance() is called.
}

public static synchronized Singleton getInstance() {

//The keyword "synchronized" makes it thread safe so that two threads invoking getInstance()
//at the same time cannot create two instances when a context switch happens so as to
//facilitate this scenario. In general this can happen even with 'n' threads invoking getInstance().
//"synchronized" keyword is used to eliminate such scenarios.

if (null == instance) {
instance = new Singleton();
}
return instance;
}
}
</nowiki>

*In Ruby, we can achieve singleton classes by mixing-in the 'Singleton' module as follows. Here, "SingletonClass" is the name of the singleton class that is being created.
<nowiki>
require 'singleton'
class SingletonClass
include Singleton
...
end
</nowiki>

====When should we use Singleton ? ====
There is a lot of criticism to the use of singleton pattern. So, how do we decide whether an object should be singleton or not ?
For an object to be considered as a singleton object, they must satisfy three requirements:
#controls concurrent access to a shared resource.
#access to the resource will be requested from multiple, disparate parts of the system.
#there can be only one object. <ref>[http://stackoverflow.com/questions/228164/on-design-patterns-when-to-use-the-singleton When should we use Singleton ?]</ref>

====Advantages====
*Singletons are often preferred to global variables as they don't pollute the global [http://en.wikipedia.org/wiki/Namespace namespace] with unnecessary variables & also can be instantiated only when needed unlike global variables which always consume resources.

====Drawbacks====
*Introduces a global state into the application.
*Can make unit testing classes in isolation difficult.
Checkout the [http://www.youtube.com/watch?v=-FRm3VPhseI this] video from Misko Hevery which explains in detail when the usage of singletons is not exercised.<ref>[http://www.youtube.com/watch?v=-FRm3VPhseI Why Singletons are bad]</ref>

===Adapter===

“If it walks like a duck and quacks like a duck, then it might be a turkey wrapped with a Duck Adapter.”

=====Definition=====
The Adapter Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces.
- Head First Design Patterns

=====Overview=====
* Adapter pattern involves wrapping objects to make their interfaces look like something they are not. This enables us to adapt a design expecting one interface to a class that implements a different interface.
* Real World Adapters - The name “Adapter Design Pattern” is derived from the fact that the design pattern exactly mirror the behavior of a real world adapter, but in an Object Oriented Manner. Consider a normal use-case of an Adapter in real world. If you own a laptop manufactured in the US and want to connect it to a wall-socket plug in Europe, you will not be able to do so. The wall socket plug in Europe exposes an AC outlet and the US laptop charger is not designed to work with that directly. So the Adapter sits between the plug of your laptop and the European wall-socket outlet. Its job is to adapt the European outlet so that you can plug your laptop to it and receive power.
* On the similar lines, consider that you have an existing software system and you want to make it work against some new third-party vendor class library. Now this new vendor might have designed their library such that the interface exposed by it is different that the previous vendor library against which you have the working software system. Changing your existing code to match this new vendor interface might prove to be a cumbersome and high-cost operation. Also if you decide to change the library sometime again the future, you would have to do the same changes again. Enter Adapter Design Pattern.
* The Adapter Design Pattern acts as the middleman by receiving requests from the client and converting them into requests that make sense to the vendor classes.

Pictorially, this can be depicted as follows -

=====Example usage of Adapter Pattern=====
* Third Party Libraries: Wrappers are used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.
* Wrapper Functions in Java: in java there is wrapper functions for primatives. For example the Integer class is a wrapper class for the primitive int
* An example would be where a square class can be wrapped so that it can be used as a rectangle also.
* Transformation of format of Dates: "Transforming the format of dates. YYYY-MM-DD to MM/DD/YYYY or DD/MM/YYYY"

=====Conceptual Work-out of the Adapter Pattern=====
* Suppose the object that is going to be making the requests is called as “Client”. The Client is implemented expecting some interface.
* Let “Adaptee” be an object that can perform the actions that the Client is going to request. However, the interface implemented by the “Adaptee”, that is the methods or even method signatures exposed by the Adaptee differ than what the Client expects.
* Now, to make Client and Adaptee work together, we use the Adapter Design Pattern. This Adapter will need to implement the interface expected by the Client. Let us call this interface as the “target interface.” So the methods exposed by the Adapter interface conform to what the Client expects. The Adapter will also hold an instance of the “Adaptee.” This will ensure that Adapter can call the methods of this instance of Adaptee. Thus, the classic implementation of Adapter Pattern is using the Object-Oriented concept of “Composition”

Pictorially, it can be viewed as follows -

=====Coding Example - Adapter Pattern in Java=====
* We will use the standard Duck-Turkey example. Suppose, there is an interface “Duck” which exposes methods “quack” and “fly”. Let us assume that there is an interface “Turkey”, exposing “gobble” and “fly”. Let us also assume that the “fly” supported by Turkey is not the same as the “fly” supported by the Duck. (Turkey can not fly as high as a duck can or something on those lines.)

public interface Duck {
public void quack();
public void fly();
}
public interface Turkey {
public void gobble();
public void fly();
}

* Suppose, there is a ‘MallardDuck’ class that implements Duck Interface.

public class MallardDuck implements Duck {
public void quack() {
System.out.println(“Quack\n”);
}
public void fly() {
System.out.println(“Fly\n”);
}
}

* Now, suppose enough number of Objects of “MallardDuck” are not present and therefore we want some Turkeys to be adapted to support Duck Interface. This means that a Client will fire method invocations expecting a Duck Interface. Hence, ‘Duck’ is our target interface. As explained in the previous section, the Adapter would need to implement the target interface. This should internally call Turkey’s methods. An instance of Turkey will be passed to this Adapter.

public class TurkeyAdapter implements Duck {
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
/* quack method calls the gobble method of the Turkey*/
public void quack() {
turkey.gobble();
}
public void fly() {
turkey.fly();
}
}

* Testing that Adapter works: Suppose, there is a function testDuck which calls the “quack” and “fly” methods of the “Duck” passed to it. Following code creates a WildTurkey object. Passes that object to an instance of TurkeyAdapter class specified above. The corresponding TurkeyAdapter class is then passed to the testDuck method.

static void testDuck(Duck duck) {
duck.quack();
duck.fly();
}
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
testDuck(turkeyAdapter);

* In this way, adapter pattern allows us to use a client with an incompatible interface by creating an adapter that does the conversion. This results in decoupling the client from the implemented interface.
* However, if we expect the interface to change over time, the adapter encapsulates that changes so that the client doesn’t have to be modified each time it needs to operate against a different interface.
* This is possible because the Adapter pattern binds the client to an interface and not an implementation. We could use several adapters each converting a different backend set of classes as long as they adhere to the same target interface.

=====Coding Example - Adapter Pattern in Ruby=====

* Let us elaborate on the same example that was used in the lecture. Suppose we have classes SquarePeg, RoundPeg and RoundHole. RoundHole class supports a method peg_fits? which expects a “peg” object as an input. The method determines if the peg fits in it or not if the radius of the peg passed as an argument is smaller than the radius of the RoundHole. Now since SquarePeg does not have a radius, we will need an Adapter that converts the “width” attribute of SqurePeg into radius and then checks if that SquarePeg can fit into the RoundHole or not.

class SquarePeg
attr_reader :width
def initialize(width)
@width = width
end
end
class RoundPeg
attr_reader :radius
def initialize(radius)
@radius = radius
end
end
class RoundHole
attr_reader :radius
def initialize(r)
@radius = r
end
def peg_fits?(peg)
peg.radius <= radius
end
end

Here is the Adapter class:

class SquarePegAdapter
def initialize(square_peg)
@peg = square_peg
end
def radius
Math.sqrt(((@peg.width/2) ** 2)*2)
end
end
hole = RoundHole.new(4.0)
4.upto(7) do |i|
peg = SquarePegAdapter.new(SquarePeg.new(i.to_f))
if hole.peg_fits?( peg )
puts "peg #{peg} fits in hole #{hole}"
else
puts "peg #{peg} does not fit in hole #{hole}"
end
end

=====Object Adapters vs. Class Adapters=====

* All the examples of Adapter that we have seen so far are the Object Adapters.
* Implementing Class Adapter is tricky since it requires multiple inheritance support in the programming language.
* In case of Object Adapters, we use “Composition” i.e. the Adapter holds an instance of Adaptee. In the case of Class Adapters, we use “Inheritance” i.e. the Adapter class is inherited from both Target class and the Adaptee class.
* The Class Adapter is thus committed to a specific adaptee class. But the hidden advantage behind this is that it does not require to re-implement the entire Adaptee class. There is also the fact that a Class Adapter can just override the methods of Adaptee is it wants to.
* Therefore, Class Adapters are not as flexible as Object Adapters.

===Command===

"Command Pattern equals Encapsulating Method Invocations"

====Definition====
"By encapsulating method invocation, we can crystallize pieces of computation, so that
the object invoking the computation doesn't need to worry about how things are done. It just uses the crystallized method to get things done" - Head First Design Patterns

====Overview====
The command pattern allows one to decouple the requester of an action from the object that actually performs the action.

This decoupling is achieved by introducing a command object which encapsulates the request to do something on an object i.e.the action to be taken or the methods to be invoked and exposes these via a single API. So the requester will only need to invoke this well exposed and simple API of the command object and the implementation of this API will contain calls to the methods of the object on which actual actions are to be done. <ref>[http://www.javaworld.com/javaworld/javatips/jw-javatip68.html Design Patterns in Java]</ref>
It achieves two things - One, the requester object code can remain simple. It does not need to take into consideration the details about how the action is going to be performed, it will only need to worry about the API exposed by the Command Object corresponding to the object whose actions are to be invoked. And two, the object on which the actions are invoked need not worry about who invoked them. The only "route" via which they would have been invoked is via the Command object specific to this object.
<ref>[http://java.dzone.com/articles/design-patterns-command Command Design Pattern]</ref>

====Example Usage of Command Pattern====
* A calculator with unlimited number of undo’s and redo’s
* "Thread pools” - A typical, general-purpose thread pool class might have a public addTask() method that adds a work item to an internal queue of tasks waiting to be done. It maintains a pool of threads that execute commands from the queue. <ref>[http://en.wikipedia.org/wiki/Command_pattern Command Pattern]</ref>
* Say we have designed an image editor and user can have the option of opening file from various ways like menu, tool bar, double click on a file in the explorer. The solution is the command pattern where the FileOpen command is associated in the viewer itself and when the command executes the file is shown in the viewer.
<ref>[http://www.codeproject.com/KB/books/DesignPatterns.aspx Design Patterns-codeproject]</ref>

====Conceptual work-out of the Command Pattern====
* Let us assume that there is an object "Client" which needs to invoke some action of Object "Receiver".
* Let us also assume that this "action" is a cumulative computation and it might involve invoking multiple methods of Receiver object.
In absence of Command Pattern, "Client" will invoke "Receiver's" methods via code statements like receiver.method1(), receeiver.method2() etc. This would mean that Client has to know exactly which methods and in which sequence are required to be called for the specified action
to take place. Thus, it implies a higher level of coupling and hence a dependency between Client and Receiver objects.
However, using a Command object specific to the Receiver object will help in decoupling this dependency.
* The Command object will only provide a single method, say "execute()" and this method will encapsulate all the method invocations of Receiver object. In this way, the methods of Receiver object for executing an action and the Receiver object itself are bound together in the Command object. <ref>[http://www.alexmcferron.com/command.html http://www.alexmcferron.com/command.html]</ref>
* The Client object will then create the Command Object and pass it to an intermediate "Invoker" object where it will get stored.
* At some point in the future, the Invoker object will invoke the "execute()" method of the Command Object passed to it, which in turn will culminate in calling all the methods of Receiver Object that are required to be called for the original specified action to take place.

Pictorially, this can be visualized as follows -

[[Image:Command kp.png]]

<ref>[http://www.allapplabs.com/java_design_patterns/command_pattern.html http://www.allapplabs.com/java_design_patterns/command_pattern.html]</ref>

====Coding example: Command Pattern in Java====

This example is inspired from the example given in Head First Design Patterns

Suppose there is a "RemoteControl" that operates lights and other such devices in a house. The remote might have on and off buttons for every light and pressing those buttons might only invoke "on" and "off" actions on those lights. However what if the same Remote is to be
used for controlling a GarageDoor? GarageDoor will not have on and off methods but "up" and "down" methods. One way around this would be including "if" statements in RemoteControl code that checks if the device being controlled is a GarageDoor, then invoke "up" instead of "on". However, this is not a robust method. If you decide to support a new device in the future, more "else if" statements will get added. The RemoteControl logic will become complex and it will be closely coupled with all the devices. This does not exhibit good Object Oriented design. However, using Command Pattern will ease out the problem. We can have one Command Object per device and specifically for each action on each device.

This command object's execute() method will encapsulate calls to "on" or "off". This achieves two things. One, the RemoteControl code can now be simple. It will only invoke "execute()" method of whichever device is being controlled. Also adding support of new devices in the future becomes easy.

Java provides an Interface called "Command". It supports only one method, "execute()"
The Command Interface can be follows

public interface Command {
public void execute();
};

Now, there will be a GarageDoorOpen command object that should implement the Command Interface.

public class GarageDoorOpenCommand implements Command {
GarageDoor garagedoor;
public GarageDoorOpenCommand(GarageDoor garagedoor) {
this.garagedoor = garagedoor;
}
/* execute method encapsultes the call to "up" */
public void execute() {
garagedoor.up();
}
}

Now remains the client and Invoker classes. Our Invoker class should only call execute method on whatever Command Object is passed to it.
Also, the Client object should create a Command object, pass it to Invoker object.

public class RemoteControlInvoker {
Command cmd;
public void setCommand(Command cmd) {
this.cmd = cmd;
}
public void buttonPressed() {
cmd.execute();
}
/* The Invoker object will only call execute on the command object to which its local
Command object was set to.
*/
}
public class RemoteControl {
public static void main(String[] args) {
RemoteControlInvoker rmtInvoker = new RemoteControlInvoker();
GarageDoor garageDoor = new GarageDoor();
GarageDoorOpenCommand gdOpenCmd = new GarageDoorOpenCommand(garageDoor);
rmtInvoker.setCommand(gdOpenCmd); //Pass the created Command Object to Invoker
rmtInvoker.buttonPressed(); //Let the Invoker invoke action on the Receiver GarageDoor
}
}

In this way, the Command object encapsulates a request by binding together a set of actions on a specific receiver. It does this
by packaging the actions and the receiver and exposing just one method - execute(). From the outside, no other objects really know
what actions get performed on a receiver, they just know that by calling "execute()", their request will be processed.

====Coding example: Command Pattern in Ruby====

In Ruby, because of the presence of "Closures", implementing a Command Pattern is a fairly straightforward. <ref>[http://www.scribd.com/doc/2217773/Design-Patterns-in-Ruby Design Patterns in Ruby]</ref>

Formally, a closure is basically a function or a method (or even a block, in the context of Ruby) that has the following twp properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods.blocks
* It saves the lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.
<ref>[http://expertiza.csc.ncsu.edu/wiki/index.php/CSC/ECE_517_Fall_2011/ch1_1d_sr Wiki Chapter On Closures]</ref>

The “Proc” class in Ruby supports a method “call” by which the block of code saved in the Proc class can be “called” and executed. In this scenario, the Proc class (which might be an output of the ‘lambda’ function) can be considered as an equivalent of the “invoker” class and the block of code passed to it to be the “Command” object.

However, using Procs for implementing Command Pattern is not applicable always. Whenever it is required to pass commands between address spaces or save commands to a file and later load them into a Ruby program. Proc objects can not be stored or restored using marshal module. Therefore, for following two reasons, using Proc objects is not enough for Command Pattern -
* When command objects need to be Persistent
* When command objects need to be sent to a remote objects.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/]</ref>

In such cases, one would have to explicitly implement Command objects via “Command” class.

Below is an example of Command Pattern in Ruby using an explicit class and not using the Proc class. In this example, “CheckMemory” extends Command class and the Installer class supports “install”, “uninstall” methods. Installer class need not worry about the instance of class passed to the “add_command” method.
<ref>[http://blog.ashwinraghav.com/2011/03/14/design-patterns-in-ruby-composite-iterator-commandpart-2/ Ruby Design Patterns]</ref>

class Command
def initialize(description, proc1, proc2)
@description = description
@function = proc1
@inverse = proc2
end
def execute
@function.call unless @function.nil?
end
def unexecute
@inverse.call unless @inverse.nil?
end
end

class CheckMemory < Command ##ireversible
def initialize
proc1 = Proc.new do
puts "Checking Memory..."
end
proc2 = Proc.new do
puts "Mem Check need not be reversed"
end
super("Checking memory avalability", proc1, proc2)
end
end

class Installer
def initialize
@commands = []
end
def add_command command
@commands << command
end
def install
@commands.each {|c| c.execute}
end
def uninstall
@commands.reverse.each do |command|
command.unexecute
end
end
end

installer = Installer.new
installer.add_command(CheckMemory.new)
installer.add_command(CreateFile.new)
installer.installinstaller.uninstall

====Advanced Command Pattern Features====

=====Supporting Undo operation=====
Providing "undo" functionality to a software is an important feature addition. Many softwares like editors need to keep track of previous actions performed and then let user undo some or all of them on demand. The Command Pattern lends itself in a very nice manner for
implementing such functionality. <ref>[http://stackoverflow.com/questions/2214874/implementing-the-command-pattern http://stackoverflow.com/questions/2214874/implementing-the-command-pattern]</ref>

When Commands support undo, they have an undo() method that mirros the execute() method. Whatever execute() last did, undo() reverses it.
In the above code example, the Command Interface would need to have a method undo and the GarageDoorOpenCommand class will need to implement
it. It can just have a call to "down" method on the GarageDoor.
In more general sense, we would need to have a Command object that always points to the last Command that was executed. Whenever an undo
action needs to be done, the undo() method of object to which this command object is pointing to would be called. <ref>[http://www.java2s.com/Code/Ruby/Design-Patterns/UndobyaCommand.htm Undo By a Command]</ref>

=====The "NoCommand" Object=====
The NoCommand object is an example of null object. A null object is useful when there is no meaningful object
to return and the responsibility of handling null objects is not adviced.
<ref>[http://sourcemaking.com/design_patterns/command http://sourcemaking.com/design_patterns/command]</ref>

=====The "Meta" Command Pattern=====
Meta Command Pattern allows us to create macros of Command objects so that multiple actions can be executed
via a single call. This means that the execute() method of a MetaCommand Object will involve a series of calls of "execute()" methods
of other Command Objects.
<ref>[http://www.voelter.de/data/pub/metacommand.pdf http://www.voelter.de/data/pub/metacommand.pdf]</ref>

===Strategy===

==Conclusion==

==References==
<references/>

==External Links==

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:56:32Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:50:07Z

Sskanitk: /* Conceptual work-out of the Command Pattern */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:49:45Z

Sskanitk: /* Conceptual work-out of the Command Pattern */

File:Command kp.png

2011-10-21T01:48:53Z

Sskanitk:

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:44:38Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:39:35Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:35:58Z

Sskanitk: /* Advanced Command Pattern Features */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:35:14Z

Sskanitk: /* Coding example: Command Pattern in Ruby */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:33:49Z

Sskanitk: /* Conceptual work-out of the Command Pattern */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:32:54Z

Sskanitk: /* Coding example: Command Pattern in Java */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:31:55Z

Sskanitk: /* Coding example: Command Pattern in Java */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:25:52Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:25:33Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:25:00Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:24:30Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:24:01Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:23:36Z

Sskanitk: /* Command */

CSC/ECE 517 Fall 2011/ch4 4h kp

2011-10-21T01:22:53Z

Sskanitk:

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-25T17:27:11Z

Sskanitk:

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://diveintopython.org/getting_to_know_python/declaring_functions.html]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature. [http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html]

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References and External Links==

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 1. Closures: A Simple Explanation (using ruby) ''by Alan Skorkin'']

[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html 2. Raganwald; Closures and Higher Order Functions]

[http://diveintopython.org/getting_to_know_python/declaring_functions.html 3. Dive into Python: 2.2. Declaring Functions]

[http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf 4. Functional Programming and the Lambda Calculus ''by Stephen A. Edwards'']

[http://innig.net/software/ruby/closures-in-ruby.rb 5. Closures in Ruby ''by Paul Cantrell'']

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ 6. Understanding Ruby Blocks, Procs and Lambdas ''by Robert Sosinski'']

[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ 7. Tiny Hippos; Closure in JavaScript - With Examples]

[http://stackoverflow.com/questions/233673/lexical-closures-in-python 8. Stack Overflow; Lexical closures in Python]

[http://gafter.blogspot.com/2007/01/definition-of-closures.html 9. Neal Gafter's Blog; A definition of Closures]

[http://www.artima.com/intv/closures.html 10. Blocks and Closures in Ruby: A Conversation with Yukihiro Matsumoto, Part III ''by Bill Venners'']

[http://porkrind.org/missives/closures-in-straight-c/ 11. Porkrind Dot Org Missives; Closures in Straight C]

[http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/ 12. Closure Sale; Lambda Abstractions in C]

[http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html 13. "Blocks" in Clang (aka closures) ''by Chris Lattner'']

[http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html 14. Insight Into Nothing: How to Hack Closures in your C Code (or "The Closure Design-Pattern in C")]

[http://kfsone.wordpress.com/2010/02/21/c-closures/ 15. kfsone's pittance; C++ Closures]

[http://stackoverflow.com/questions/356950/c-functors-and-their-uses 16. Stack Overflow; C++ Functors - and their uses]

[http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm 17. Java in a Nutshell; 3.12. Anonymous Classes]

==Further Reading==

[http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html 18. Ricky's Technical Blog; Why Java Needs Closures (It Already Has Them)]

[http://gafter.blogspot.com/2007/01/definition-of-closures.html 19. Neal Gafter's Blog; A Definition of Closures]

[http://blogs.oracle.com/jag/entry/closures 20. James Gosling: on the Java Road; Closures]

[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html 21. JavaWorld; Understanding the closures debate ''By Klaus Kreft and Angelika Langer'']

[http://c2.com/cgi/wiki?ScopeAndClosures 22. Cunningham & Cunningham, Inc.; Scope and Closures]

[http://lua-users.org/lists/lua-l/2004-11/msg00185.html 23. Closure of lexical environment in Scheme closures ''by Dr. Rich Artym'']

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 24. Zdeněk Troníček's blog; Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 25. Lambda expressions and closures for C++ ''by Jeremiah Willcock, Jaakko J¨arvi, Doug Gregor, Bjarne Stroustrup, and Andrew Lumsdaine'']

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 26. Thought Palace; Blocks/Closures For C!]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:40:48Z

Sskanitk: /* References and External Links */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature. [http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html]

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References and External Links==

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 1. Closures: A Simple Explanation]

[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html 2. Closures and Higher order functions]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 3. Closures a form of Anonymous]

[http://www.artima.com/intv/closures.html 4. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 6. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 7. Closures in Java]

[http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf 8. Functional Calculus using Lambda notation]

[http://innig.net/software/ruby/closures-in-ruby.rb 9. Closures in Ruby]

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ 10. Understanding Ruby Blocks and Closures]

[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ 11. Closures and JavaScript]

[http://stackoverflow.com/questions/233673/lexical-closures-in-python 12. Lexical Closures in Python]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:40:32Z

Sskanitk:

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature. [http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html]

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References and External Links==

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 1. Closures: A Simple Explanation]

[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html 2. Closures and Higher order functions]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 3. Closures a form of Anonymous]

[http://www.artima.com/intv/closures.html 4. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 6. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 7. Closures in Java]

[http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf 8. Functional Calculus using Lambda notation]

[http://innig.net/software/ruby/closures-in-ruby.rb 9. Closures in Ruby]

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ 10. Understanding Ruby Blocks and Closures]

[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ 11. Closures and JavaScript]

[http://stackoverflow.com/questions/233673/lexical-closures-in-python Lexical Closures in Python]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:39:42Z

Sskanitk: /* References */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature. [http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html]

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References and External Links==

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 1. Closures: A Simple Explanation]

[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html 2. Closures and Higher order functions]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 3. Closures a form of Anonymous]

[http://www.artima.com/intv/closures.html 4. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 5. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 6. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 7. Closures in Java]

[http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf 8. Functional Calculus using Lambda notation]

[http://innig.net/software/ruby/closures-in-ruby.rb 9. Closures in Ruby]

[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ 10. Understanding Ruby Blocks and Closures]

[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ 11. Closures and JavaScript]

[http://stackoverflow.com/questions/233673/lexical-closures-in-python Lexical Closures in Python]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:30:32Z

Sskanitk: /* C : function pointers */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature. [http://lists.cs.uiuc.edu/pipermail/cfe-dev/2008-August/002670.html]

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:28:48Z

Sskanitk: /* Closures and Static Scoping */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:28:28Z

Sskanitk: /* Closures and Static Scoping */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

Consider the below Scheme code snippet. The example is derived from [http://lua-users.org/lists/lua-l/2004-11/msg00185.html this thread].

(let* ((foo ; define foo
10)
(incfoo1 ; define incfoo1
(lambda () (+ foo 0.1)))
(bar ; define bar
65)) ; bar not used (just for symmetry)
(incfoo1)) ; prints 10.1

The variable "foo" is in static scope when the function "incfoo1" is defined. Later, when incfoo1 is called, it will print "10.1", thus remembering the value "10" that foo was assigned to, even though it is no longer in scope at the time of the call.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:15:26Z

Sskanitk: /* Example implementation using Function Objects */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from
[http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:15:07Z

Sskanitk: /* Example implementation using Function Objects */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from [ http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread]. about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme, both of which are statically typed.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:14:12Z

Sskanitk: /* C++ : Function Objects */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. This example is cited from [ http://stackoverflow.com/questions/356950/c-functors-and-their-uses this discussion thread] about closures in C++

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping, is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such languages include JavaScript and Scheme.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T16:07:26Z

Sskanitk: /* C : function pointers */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions. [http://porkrind.org/missives/closures-in-straight-c/]

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent. [http://mikeburrell.wordpress.com/2008/03/31/lambda-abstractions-in-c/]

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
Static scoping, also known as lexical scoping is scoping in which variables are looked up according to the context in which they are defined. This ensures that the lexical context is maintained in languages that allow for first class-functions, which means the first class functions create closures. [http://c2.com/cgi/wiki?ScopeAndClosures] Examples of such classes include Javascript and Scheme.

==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T15:58:50Z

Sskanitk: /* An example implementation of Closures in C */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well. [http://nothingintoinsight.blogspot.com/2009/02/how-to-hack-closures-in-your-c-code-or.html]

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T15:57:04Z

Sskanitk: /* Challenges For Closures in Statically Typed Languages */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection. [http://www.artima.com/intv/closures.html]

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T15:56:18Z

Sskanitk: /* Example in Python */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined. [http://stackoverflow.com/questions/233673/lexical-closures-in-python]

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-07T15:55:33Z

Sskanitk: /* Example in JS */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue" [http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined.

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-06T21:51:42Z

Sskanitk: /* Example in Python */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
Closures are a topic of interest in computer science. While they provide useful functionality, they are more often included in dynamic languages than in statically typed languages. This article covers what closures are and why they are useful. It also explains why implementing closures in statically typed languages is a challenge, giving examples along the way from both dynamically typed and statically typed languages.

==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue"

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

For a highly powerful and dynamically typed language like Python, closures act as one more useful feature.
Below is a simple example of closures in Python. The closure names "_inc" will remember the value of variable "step" which was in scope
when it the closure function was defined.

def counter(start=0, step=1):
x = [start]
def _inc():
x[0] += step
return x[0]
return _inc
c = counter()
c() # This will output "1"
c() # This will output "2"
c() # This will output "3"

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Implementing Closures in Statically Typed Languages===
The following sections discuss specific statically typed languages in relation to closures.

====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes.

Anonymous inner classes are unnamed classes that are simultaneously defined and instantiated with a single ''new'' operator.
The following define the syntax for anonymous inner classes: [http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm]
new class-name ( [ argument-list ] ) { class-body }

new interface-name () { class-body }

The following is an example closure implementation in Java from [http://rickyclarkson.blogspot.com/2007/10/why-java-needs-closures-it-already-has.html Ricky's Technical Blog]. The "closure" is in that the method run' inside the new 'Runnable' object can reference the variable 'use'.
public void example()
{
final double use=Math.random()*10000;

SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
System.out.println(use);
}
});
}

Anonymous inner classes have limitations as closures. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise and overly verbose in comparison to the use of closures in dynamically typed languages like Ruby.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-06T18:49:52Z

Sskanitk: /* Example implementation using Function Objects */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue"

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Limitations of Statically Typed Languages===
====Lexical Scope====
====Functions not as first class citizens of the language====
===Implementing Closures in Statically Typed Languages===
====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function. [http://stackoverflow.com/questions/356950/c-functors-and-their-uses]

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }
private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes, though there are limitations. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise as it is to use closures in dynamically typed languages like Ruby. [http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-06T18:48:17Z

Sskanitk: /* C++ : function objects */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue"

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Limitations of Statically Typed Languages===
====Lexical Scope====
====Functions not as first class citizens of the language====
===Implementing Closures in Statically Typed Languages===
====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : Function Objects====

Implementing closures in C++ requires a different philosophy because of the Object Oriented nature of the language. Just having a struct of function pointer pointing to the function to be used as closure and a pointer to the context of the function will not suffice. In C++, it is not possible to pass around pointer to a member function. In C++ world, a member function is part of the context of the object and hence can not be accessed when the object ceases to exist or goes out of scope. On the inside, calling a member function is equivalent to calling a piece of code i.e. the function with a hidden argument "Object *this" which is actually a reference to the object instance [http://kfsone.wordpress.com/2010/02/21/c-closures/]. A specific C++ program construct called as a "functor" of function object can be used to implement an equivalent of closures.

===== Example implementation using Function Objects =====

Function objects are objects specifically designed to be used with a syntax similar to that of functions. In C++, this is achieved by defining member function operator()(). In other words, a functor or a function object would be the object of a class that defines the function call operator i.e. "operator () ()" as a member function. This will mean that using the object with "()" would be equivalent to calling a function. Also the data members of this class can be thought of as the variables that constitute the context of the function.

Consider the below example. Whenever you create the object "Adder10" and actually do the call of "Adder10" with argument "20", it will add 20 to 10 and return the result. The private data member "x" is set once via the constructor at object initialization. Whatever is passed as the argument will be added to the value of "x" and be returned.

class ClosureAdd {
ClosureAdd(int x) : x(x) {}
int operator()(int y) { return x + y; }

private:
int x;
};
// Now you can use it like this:
ClosureAdd Adder10(10); // create a functor
int i = Adder10(20); // and "call" it
cout << i // this will print "30" as the answer

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes, though there are limitations. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise as it is to use closures in dynamically typed languages like Ruby. [http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-06T14:30:51Z

Sskanitk: /* An example implementation of Closures in C */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue"

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Limitations of Statically Typed Languages===
====Lexical Scope====
====Functions not as first class citizens of the language====
===Implementing Closures in Statically Typed Languages===
====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

Below is the definition of the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : function objects====

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes, though there are limitations. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise as it is to use closures in dynamically typed languages like Ruby. [http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]

CSC/ECE 517 Fall 2011/ch1 1d sr

2011-09-06T05:25:22Z

Sskanitk: /* Example in JS */

Wiki Chapter: CSC/ECE 517 Fall 2011/ch1 1d sr

''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.''
__TOC__
==Introduction==
==Closures==

===What are Closures?===
A '''closure''' is basically a function or a method (or a block, in the context of ruby) that has the following two properties:
* It is a first-class function, meaning it can be passed around like an object or as a value parameter to other functions/methods/blocks
* It saves its lexical environment, meaning it captures the variables within scope at its creation and maintains them even if they later go out of scope.[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

In order for a programming language to be able to support closures, it must support the notion of "first class functions."
A first class function is a function that can be treated like an object, such as passing it as a parameter or returning the function as the result of another method. [http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html] Since a closure can be passed around as a value before calling it, it can be called in a completely different scope than the one in which it was created and it is because of this that it needs to retain the knowledge of the lexical environment in which it was defined. [http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html]

===Why Closures ===

* For [http://en.wikipedia.org/wiki/Functional_languages functional languages], which themselves are essentially stateless, closures offer a way to store some kind of state at least for as long as the closure lives. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Closures help functional languages to be terse in expressing logic. Closures also offer a very succinct way of performing some neat programmatic operations i.e. if a closure modifies the value of a variable, it will retain the new value the next time the closure was invoked. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
* Higher order, special purpose functions like select and inject in Ruby, which do a lot of useful stuff with very little code are possible only because the language supports closures.
* Currying of functions in languages like Ruby is only made possible through the use of closures. Currying is taking a function and one or more of its parameters to produce a new function with fewer parameters, which can be useful for human readability and coding.[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
* For procedural or imperative languages, the argument for closures is a twofold one. Procedural languages already have mechanism to store state via the use of global variables, static variables etc. but closures offer a way to pass around units of computation that can be executed later. The function pointers and the callback function ideology in C is centered around this motivation. For object-oriented imperative languages like C++ or the Objective-C, closures provide for the lack of a syntactically light-weight way to define simple object functions for the effective use of several generic algorithms like those offered by Standard Template Library.

===Closures in Dynamically Typed Languages===

A dynamically typed language is a programming language which does majority of its type-checking at run-time instead of compile-time [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing]. '''In dynamic typing, values have types but variables do not.''' Hence, a variable can refer to a value of any type. This important property of dynamically typed languages offers itself as a convenient way of implementing and supporting closures. For closures, a variable can point to a block of code and the associated lexical environment. A special-purpose programming construct called "'''''lambda'''''" is used in some languages to express '''anonymous functions''' i.e functions which are not bound to a name at runtime.
Lambda is used to generate new functions dynamically. The concept of "lambda" has been derived from the lambda calculus in the functional programming [http://www.cs.columbia.edu/~sedwards/classes/2010/w4115-spring/functional.pdf].

====Example use of Closures in Dynamically Typed Langauges====
The following are examples of closure usage in some of the dynamically typed languages. These examples cover a particular and common usage of closures, but all the aspects and subtleties of closures in a particular language (in Ruby, for example, there are Seven distinct ways of implementing closure or closure-like structures[http://innig.net/software/ruby/closures-in-ruby.rb]) will not be covered here.

=====Example in Ruby=====

In Ruby, for all intents and purposes, "Blocks" [http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/] are closures. They are closed with respect to the variables defined in the context in which they were created, regardless of the context in which they are called. The subtle difference is that a "Block" can not be passed as a specific named parameter and "yield" is the only way by which control can be given to the block that was passed to the method in which yield is called.

class ClosureTest

def initialize(x)
@x = x
end

def call_closure(ClosureBlock)
ClosureBlock.call @x
end
end
a = 100
ClosureBlock = lambda {|x| puts x+a}
ClosureObj = ClosureTest.new(10)
ClosureObj.call_closure(ClosureBlock) # This will output "110"
a = 200
ClosureObj.call_closure(ClosureBlock) # This will output "210"

As seen in the above example, "ClosureBlock" is a closure. The use of lambda construct means that the ClosureBlock variable would be of type "Proc". When ClosureBlock is defined, the variable "a" is in its scope and hence it will remember the value that "a" was bound to. However when ClosureObj, an object of class ClosureTest calls "call_closure" method with ClosureObj passed as a parameter (closures can be passed around as objects), it will remember the value of "a" even though "a" is now no longer in scope and will print "100+10" as the answer. On the similar notes, when "a" is modified and call_closure is invoked again, the ClosureBlock will pick up the value of "a" in the lexical context in which ClosureBlock was created i.e. it will pick up the latest value of "a".

=====Example in JS=====

JavaScript is also a dynamically typed language and it supports closures in its most rudimentary form.
It is not required to use lambda construct to be able to use closures in JavaScript.

In below example, in function "clickMe", the output of 'alert' would be "originalValue".
The function block gets created on the fly while calling "calledFunction" in "clickMe". The passed function is a closure and it remembers the value of "value" that was within the context of its definition. So when "passedFunction" is called from calledFunction, it will assign the "newValue" to "value" even though "value" is not in the scope of calledFunction. This is possible because of closures. The output of next 'alert; would be this "newValue"

function calledFunction(passedFunction) {
passedFunction("newValue");
}
function clickMe() {
var value = "originalValue";
alert(value);
calledFunction(function(externalValue) {
value = externalValue;
});
alert(value);
}

=====Example in Python=====

==Closures in Statically Typed Languages==
===Challenges For Closures in Statically Typed Languages===
Closures are not usually implemented in statically typed languages, due to their nature. The following are some obstacles statically typed languages must overcome:
* While dynamically typed languages allow for any variable to be associated with any type, static languages require types declared at compile time. This would require a specific type for closures if they were implemented in a statically typed language.[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
* Many statically typed languages keep track of in-scope variables with a stack-based system: variables are pushed on when entering a scope and popped when exiting a scope. This can be a challenge for implementing closures in statically typed languages, since closures must maintain access to variables even when they go out of scope.
* Since closures require saving the lexical environment of its definition, the ways and means provided by a language for doing this determines the level of difficulty and effectively the feasibility of implementing closures in that language. In statically typed languages like C, one way of doing this would be to make a copy of all the variables that are needed when a closure was defined and passing this copy around as its context. Alternative to this copying strategy, one way could be to retain a reference to them, thus making them not eligible for garbage collection.

===Limitations of Statically Typed Languages===
====Lexical Scope====
====Functions not as first class citizens of the language====
===Implementing Closures in Statically Typed Languages===
====C : function pointers====

* The concept of closures requires that a block of code along with the lexical context of its creation needs to be saved. C's context is based on the local variables which are created on the stack frame corresponding to the function currently being executed, the registers of the CPU which might store specific values and the global variables. Anything other than this is handled by the dynamic memory allocation provided by malloc.

* The programming construct of "'''''function pointers'''''" is a useful tool for implementing closures in C. A function pointer is, as the name suggests, a pointer which stores address of any function. One can pass this function pointer holding the address of a particular function to another function as a parameter. The function which receives the function pointer as a parameter can now "call" or execute the function pointed to by the function pointer. This, in its most rudimentary form, is the basic technique by which C can pass along blocks of code to another functions.

* However the definition of closure also mandates that the lexical context at the time of its creation need also be saved and accessible later. This proves to be a painful task and one needs a logic to provide this functionality in the most concise and acceptable manner. One way to do this would be to provide a programmer defined struct which holds the values of all the variables which were "in scope" of the function that is to be treated as closure.

* Note here that the struct variable which stores the values of all the variables in the lexical context of the function under consideration must not be "statically" allocated i.e. it must not be allocated on the stack of the method currently being executed. So this context saving structure variable needs to be allocated from the heap using malloc and the pointer to this "context structure" will need to be passed along with the function pointer to any functions that need to execute this later. However, note that because of the inherent nature of "statically" typed behavior, one would have to associate a particular function pointer with the function with matching signature and hence this combination of function pointer and user data struct pointer is not exactly type independent.

* "Type independence" in this context means that a function block would have to be closely tied with its signature like the data types of the parameters that the function expects, the data type of the return value that the function should return etc. So to create a different closure corresponding to a function of different signature, one would need the definition of another function pointer with compatible signature.

=====An example implementation of Closures in C=====

Consider the below Ruby block. The function "caller" defines a closure using lambda construct and returns it to a variable called ClosureVar. The variable "x" which is passed as a parameter to function "caller" forms the part of lexical environment that the closure should save and keep track of.

def caller x
puts x
lambda do
x += 1
puts "Inside closure"
puts x
end
end
ClosureVar = caller(5)
ClosureVar.call # This will output 6
ClosureVar.call # This will output 7

The below structure would be the placeholder for the closure implementation in C. Since for this example, "x" is the only variable which is part of the lexical context in which closure was defined, only that variable is included in the struct. If more variables are part of it, they would need to be included in the struct definition as well.

struct closure {
void (* call_closure)(struct closure *);
int x;
};

We will need to define the actual function which will hold the statements that were part of the block of code that constitutes the closure in the above ruby snippet.

void closure_block(struct closure * env) {
env->x += 1;
printf ("block: x is %d\n", env->x);
}

And finally, the C code snippet below would be the implementation of "caller" function.

void (*fptr_closure_block) (struct closure *) = 0; /* Define a function pointer which can point to functions whose
signature matches that of closure_block.
*/
fptr_closure_block = closure_block; /* Make this function pointer point to closure_block */

struct closure * caller(int x)
{
struct closure * ClosureVar = (struct closure *)malloc(sizeof(struct closure *));
ClosureVar->x = x;
printf ("x is %d\n",ClosureVar->x);
ClosureVar->call_closure = fptr_closure_block;
return ClosureVar;
}

As can be seen from the above example, implementing a simple closure scenario in C involves a lot of messy logic and function pointer manipulation. For implementing more advanced feature like multiple closures, an even more complicated code would be required. It is thus, not at all, intuitive to implement closures in C.

====C++ : function objects====

====Java : anonymous inner classes====
Java can provide similar functionality to closures through anonymous inner classes, though there are limitations. For simulating closures, the local variables from enclosing scopes used in the anonymous class must be declared ''final''. This is because variables are not resolved in the enclosing scope, but in the class's scope. Using Java's anonymous inner classes in this way is also not as simple to implement code-wise as it is to use closures in dynamically typed languages like Ruby. [http://gafter.blogspot.com/2007/01/definition-of-closures.html]

James Gosling, regarded as the inventor of Java, stated that "closures were left out of Java initially more because of time pressures than anything else." He also explains inner classes being added to Java to alleviate the lack of closures, but that this was not a real solution. Gosling feels he should have gone all the way to implementing closures back then. [http://blogs.oracle.com/jag/entry/closures] Proposals are currently being made for Java to include closures as a feature. [http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]

==Closures and Static Scoping==
===(Explanation)===
===Case study of Scheme===
==References==

[http://www.artima.com/intv/closures.html 1. Matz discussion on Closures]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2. Closures in C++]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3. Closures in C]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4. Closures in Java]

==External Links==

[http://www.artima.com/intv/closures.html 1]

[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf 2]

[http://jens.mooseyard.com/2008/08/blocksclosures-for-c/ 3]

[http://tronicek.blogspot.com/2007/12/closures-closure-is-form-of-anonymous_28.html 4]

[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ 5]

[http://en.wikipedia.org/wiki/First-class_function 6]

[http://en.wikipedia.org/wiki/Functional_languages 7]

[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/ 8]

[http://innig.net/software/ruby/closures-in-ruby.rb 9]

==RESOURCES TO LOOK THROUGH IN WORKING ON THE WIKI - KURT==
[http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html]
[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://www.artima.com/intv/closures.html]
[http://reprog.wordpress.com/2010/02/27/closures-finally-explained/]
[http://thejavacodemonkey.blogspot.com/2008/01/what-are-closures-and-what-do-they-mean.html]
[http://gafter.blogspot.com/2006/08/use-cases-for-closures.html]
[http://samdanielson.com/2007/9/6/an-introduction-to-closures-in-ruby]
[http://www.javaworld.com/javaworld/jw-06-2008/jw-06-closures.html]
[http://gafter.blogspot.com/2006/08/whats-point-of-closures.html]
[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/]
[http://gafter.blogspot.com/2007/01/definition-of-closures.html]
[http://martinfowler.com/bliki/Closure.html]
[http://blogs.oracle.com/jag/entry/closures]