in reply to Nailing down closures!

This is more of a general programming languages perspective of a closure, not as perl-centric as the other highly informative posts above.

The wikipedia definition could use a little explication. So a closure is a procedure and an environment in which to execute that procedure (the environment of the program at the time the closure is created). This is irrespective of whether or not the closure is bound to a name or is anonymous, whether the environment is empty, or contains bindings.

So what's an environment? The 'lexical environment' is what the procedure uses to look up variable references. In other words, a symbol table, a mapping between symbols and values. Naturally, variable declarations add to/pollute the environment. Going back to your case above, the addone closure's environment could be represented as a hash of 'i' => 1. The environment could be affected by many things, import declarations in Java/Scheme, using namespace in C++, #include <foo> in C, use Food::Bare, declaring more variables, etc. Now, let's say addone didn't have a reference to $i - then it's local environment would just happen to be empty.

Using this definition of closure, every procedure or sub you write is a closure. In the addone example, there are two bindings for $i, one in the closure's local environment (which is checked first), and another in the top level environment, when you set $i=10. When you invoke addone, we first check the environment packaged up with the addone closure for an entry for $i. We find that there is an entry for $i=>1, we increment that local entry for $i, (which doesn't affect the outer lexical environment's entry for $i=>10), and then return $i + 2.

If this is the definition of closure you're more interested in, you should definitely learn more about free and bound variables and scoping and its effects on the environment. Maybe learn Scheme, even ;-).

Hope that helps!

Allen

Replies are listed 'Best First'.
Re^2: Nailing down closures!
by xdg (Monsignor) on Dec 06, 2005 at 04:12 UTC
    Using this definition of closure, every procedure or sub you write is a closure.

    I don't think using this broad a definition helps clarify the term or how closures are used in Perl. Within Perl at least, the term "closure" refers to a subroutine that references lexical variables outside it's own scope. This has a very specific meaning and a very specific application. 

    # doesn't reference anything outside the scope of the subroutine scope

sub not_a_closure {
  my $i;
  $i++;
  return $i
}

# references a package variable, not a lexical variable

our $global;
sub also_not_a_closure {
  $global++;
  return $global;
}

# a closure -- references a lexical outside the scope

my $lexical;
sub a_closure {
  $lexical++;
  return $lexical;
}

# anonymous closure generator -- references a new variable each time

sub closure_generator {
  my $fresh_lexical;
  return sub {
    $fresh_lexical++;
    return $fresh_lexical;
  }
}

    [download]

    -xdg

    Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.

[reply]
[d/l]
      This is a pretty late reply ;-).

      I feel that you may be missing the point. Let's say you are writing an interpreter for a language with closures and have to come up with an exact specification of how code using closures should run. Well, language designers need to guarantee reasonable, consistent behavior when a programmer passes functions around - namely, if those functions have free variables, how should those free variables be resolved? It so happens that there is a reasonable, consistent, way to implement function passing, and it involves creating this notion of a closure, which is executable code + some data (the environment) that you use to resolve any free variables within the executable code, if need be. It all boils down to a construct that language designers came up with to formally describe what happens when you pass functions into other functions.

      Ask yourself - does Perl really need its own personalized definition of a closure? Why not use the one that's already in use in the PL community?

[reply]

In Section Seekers of Perl Wisdom