CSC/ECE 517 Fall 2007/wiki1 2 pk

Closures

Closures are functions which are evaluated in an environment containing bound variables. They are blocks of code which meets three criteria:

• They can be passed around as a value and
• They can be executed on demand
• They can refer to variables from the context in which it was created

They are usually found in languages which treat functions as first class values i.e. they can passed around as arguments to functions, bound to variables and even be returned from functions. Closures were initally developed in the 1960s in a language called Scheme and later adopted in other languages including Ruby and Smalltalk.

Examples

Assume, we have list of employees and we want to find the list of employees who are managers. The following ruby code shows how this can be done with closures.

def managers(emps)
  return emps.select {|e| e.isManager}
end

However, the biggest advantage of closures is that they can refer to the variables which were visible at the time they were defined. An small example using closures is shown below, where we pick the employees who have a salary greater than a thershold.

def highPaid(emps)
  threshold = 150
  return emps.select {|e| e.salary > threshold}
end

Closures can also refer to the arguments of the function in which it is defined. For example, conside the ruby code snippet below.

def paidMore(amount)
  return Proc.new {|e| e.salary > amount}
end

The binding to amount argument remains even after