Anyhow. Given this (toy) closure:

sub toggle {
  my @states = @_;
  my $index = 0;

  return sub {
    return $states[ $index++ % ( scalar @states ) ];
  }
}
[download]

This little snippet takes a list of arguments and returns a function reference. Calling the reference will return the next element in the argument list. Simple use:

my $t = &toggle qw( alfa beta gamma );
print &$t(), "\n" foreach ( 1 .. 20 );
[download]

The point is that @states and $index are unique context to each of the function references, and calling &toggle with different argument lists will give us independent function references that have distinct behaviour.

Now, given this function for currying:

sub curry {
    my ( $fnc, @arguments ) = @_;

    return sub {
        return &$fnc( @arguments, @_ );
    }
}
[download]

And this toy function for echoing the contents of a list.

sub echo {
    return join( " ", @_ );
}
[download]

With currying, we can "prime" &echo with a set of arguments that will be prepended to everything it prints out later:

my $boss = &curry( \&echo, "My", "boss:" );
my $friend = &curry( \&echo, "Johnny:" );

print &$boss qw( has pointy hair ), "\n"; # "My boss: has pointy hair
print &$friend qw( likes rock and roll ), "\n"; # etc.
[download]

What I'm trying to say

Obviously, both the &toggle closure and the &curry function are implementet in the same way, namely Perl's closures. Why the difference in naming? Why not just talk about functions like &curry as closures?

I think it is a good idea to separate these two concepts, as currying includes a function as an argument. This seems to me to be the key, as a closure in itself is a method for giving a function context (A poor man's object, as some say. Others call objects a poor man's closure.) so each closure is explicitly created and tailored to it's use.

Since currying receives its function from the outside as an argument, it does not care about what it does to whom. This makes it to me a more flexible programming technique, since I don't have to explicitly set up the inner workings of a closure. Borrowing from object oriented terminology, maybe currying can be considered as a kind of closure constructor, or factory?

In closing, I want to stress that this is my understanding of these concepts, and that I've been using the last few days to grasp what it means. If any wiser monks would point out the errors in my argumentation, I'd be more than happy.