Recursive Subroutine Reference - perl

Question

I have tested the following code with perl 5.8 (codepad) and perl 5.16 . There's probably some deeper principle I'm missing and I'm curious what the logic behind this behavior is. Thanks.
The following simple recursive subroutine reference
use strict;
use warnings;
my $fact = sub {
my $n = shift;
if ($n == 0) {
return 1;
}
return $n * $fact->($n-1);
};
print $fact->(100);
results in the error
Global symbol "$fact" requires explicit package name at line 9.
Execution aborted due to compilation errors.
declaring variable before defining it does not produce this error.
use strict;
use warnings;
my $fact;
$fact = sub {
my $n = shift;
if ($n == 0) {
return 1;
}
return $n * $fact->($n-1);
};
print $fact->(100);

Answer 1

my returns the new lexical, so it can be used to assign to it in the same statement in which it was declared. However, any further references to that name only resolve to that lexical beginning with the next statement.
So separate the declaration:
my $fact;
$fact = sub { ... $fact ... }
This rule is in fact sometimes useful; you can have an outer lexical and an inner one and assign between the two:
my $foo = 42;
{
my $foo = $foo;
$foo += 42;
print "foo is $foo\n";
}
print "foo is $foo\n";
If you have a recent version of Perl, you don't actually need to access $fact within the subroutine because the __SUB__ pseudo-constant offers a reference to the current subroutine.
use 5.016;
my $fact = sub {
my $n = shift;
if ($n == 0) {
return 1;
}
return $n * __SUB__->($n-1);
};
Note that in the first example (where the $fact variable is used within the sub), a reference cycle is created, which might lead to Perl leaking memory over time. __SUB__ is a fairly clean way to resolve that issue. (Other solutions to the problem include the Y-combinator and reference weakening.)