Closures are documented in the perlref manpage.

Closure is a computer science term with a precise but hard-to-explain meaning. Closures are implemented in Perl as anonymous subroutines with lasting references to lexical variables outside their own scopes. These lexicals magically refer to the variables that were around when the subroutine was defined (deep binding).

Closures make sense in any programming language where you can have the return value of a function be itself a function, as you can in Perl. Note that some languages provide anonymous functions but are not capable of providing proper closures; the Python language, for example. For more information on closures, check out any textbook on functional programming. Scheme is a language that not only supports but encourages closures.

Here's a classic function-generating function:

 sub add_function_generator {
    return sub { shift + shift };
    }
    

 $add_sub = add_function_generator();
    $sum = $add_sub->(4,5);# $sum is 9 now.
    

The closure works as a function template with some customization slots left out to be filled later. The anonymous subroutine returned by add_function_generator() isn't technically a closure because it refers to no lexicals outside its own scope.

Contrast this with the following make_adder() function, in which the returned anonymous function contains a reference to a lexical variable outside the scope of that function itself. Such a reference requires that Perl return a proper closure, thus locking in for all time the value that the lexical had when the function was created.

 sub make_adder {
    my $addpiece = shift;
    return sub { shift + $addpiece };
    }
    

 $f1 = make_adder(20);
    $f2 = make_adder(555);
    

Now &$f1($n) is always 20 plus whatever $n you pass in, whereas &$f2($n) is always 555 plus whatever $n you pass in. The $addpiece in the closure sticks around.

Closures are often used for less esoteric purposes. For example, when you want to pass in a bit of code into a function:

 my $line;
    timeout( 30, sub { $line =  } );
    

If the code to execute had been passed in as a string, '$line = ', there would have been no way for the hypothetical timeout() function to access the lexical variable $line back in its caller's scope.