What is a closure? I keep reading this word in programming, but never got a good explanation.

A closure is a block of code that can be passed as an argument to a function call. In languages like Lisp and Ruby closures are easily implemented. In Python you can do it, but it is a bit more code. Lambda is often used for that.

Here would be an example ...
[php]class Employee:
"""sets up an employee structure/record"""
pass

# some employee data
olaf = Employee()
olaf.name = "olaf"
olaf.salary = 55

nathan = Employee()
nathan.name = "nathan"
nathan.salary = 175

def pay(amount):
return lambda emp: emp.salary > amount

# set the pay_scale, any amount above 150 is high
pay_scale = pay(150)

print pay_scale # <function <lambda> at 0x009D70F0>

# now set the employee instance
# feeds the emp data to lambda code returned by function pay()
# this constitutes the block of code of the closure
is_high = pay_scale(nathan)

print "Is nathan paid high? ", is_high # Is nathan high paid? True

# set another employee instance
is_high = pay_scale(olaf)

print "Is olaf paid high? ", is_high # Is olaf high paid? False
[/php]
Just found a somewhat simpler example ...
[php]# define a function within a function and return it to the calling scope
# the inner function can access variables in the calling function, i.e. its closure

def times(n):
def _f(x):
return x * n
return _f

t3 = times(3)
print t3 # <function _f at 0x009D70F0>
print t3(7) # 21
[/php]
Here the inner function _f() is the block of code of the closure, similar to the lambda code in the first example.

People always come up with the generator case, and I think that's the worst way of all to show off closures. Where they really come in handy is introducing lexical scoping.

Lexical scoping just means that the environment is defined by the context in the code, not in runtime. An example in Common Lisp (because I don't really know Python and my predecessor explained it using PHP):


This is a function called add-to-list that takes a list and adds a number to each of its elements. defun defines a function, map applies a
function to each element of a list, and lambda defines an anonymous function.

Now consider the anonymous function - it references both X, a parameter to the function, and NUMBER, which is a parameter to add-to-list. It must have access to NUMBER regardless of the context in which it's called. So it's placed into a closure, where all the variables in its environment are available. In that way, MAP doesn't have to worry about providing access to variables.

This is the primary advantage closures have over other function-variable patterns, like function pointers or functors.
Anonymous functions declared in-place "just work."

Thank you vegaseat and azimuth0. I have to play with that for a while to comprehent it. By the way, vegaseat's code is Python put into a PHP code field to give it some color highlighting (use a [php] tags instead of [code]).