sub foo
{
   my $bar = sub { print "world!\n" };
   print "Hello\n";
   &$bar;  #also can be written as: $bar->();
}

foo();
#&$bar here will not work since $bar is only valid inside foo.
[download]

Unfortunately, any subroutine that you define like that will be put into the namespace of the package that it's resident in. Thus, you cannot have lexically scoped subroutines. From what I understand, we will have lexically scoped subs in Perl6.

What you want is a closure:

my $bar = sub { print shift };
sub foo {
    print "Hello\n";
    $bar->( "Saluton mondo!\n" );
}
foo();
$bar->( "Hello world!\n" );
[download]

Hmm... as I recall, the proper definition of a closure is an anonymous code reference that contains a reference to a lexically scoped variable that is defined outside of itself. Since this example doesn't really do that, is it, strictly speaking, a closure?

Cheers,
Ovid

Vote for paco!

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

Actually, it doesn't need to be anonymous or a code ref to be a closure; it just has to refer to lexical variables defined outside of its scope. This is a closure:

my $foo;
sub bar {
    print $foo;
}
[download]

Any further changes to the value of $foo in the future will not change the private value that bar() now has.

It does need to be inside another sub. The code has to be something like:

sub baz {
    my $foo=shift;
    sub bar {
    print $foo;
    }
}
baz("abc");
bar;
baz("123");
bar;
[download]

which will print abcabc. The change to the $foo variable in the second call does not affect subroutine bar. It has a 'closed', localised and personal $foo variable, that cannot be changed by outside influences - only by bar itself. Thus the name 'closure'.

Being able to define subroutines within subroutines is intentional. The main uses for this sort of thing is within AUTOLOAD methods, which allows subroutines to be generated "on demand". Usually a little bit of eval magic occurs here as well, to make sure an appropriately named sub is generated.

As pointed out above, a subroutine attaches itself to its current package, regardless of where you define it. This is exactly what you want for AUTOLOAD methods.

The perlbot man page has an example of using AUTOLOAD down the bottom. You might want to check it out if you're curious.

Cheers,
Paul

sub outside_foo {
    my $STATIC;
    my $done = 1;
    sub foo{
        $done or outside_foo();
        print "\nSTATIC is ", ++$STATIC;
    }
}
foo();
foo();
foo();
[download]

"Dogs luv me cuz I'm crazy sniffable / I bet you never knew I got ill peripherals"