You can also solve this problem using a combination of a fixed point combinator (don't worry it's not as complex as it sounds) and currying.

Basically your problem is that you have a un-nameable subroutine which you want to recurse with. The problem is you are trying to call your subroutine by name, which is not possible since it's name can never be in the proper scope. The other option then is to call-by-value instead. In order to accomplish this, all you need to do is alter your anon-subroutine to take an additional parameter, which is the function you wish to call in the recursion. It might look something like this:

my $anon = sub {
   my $func = shift;
   my $count = shift;
   if ($count--) {
        print "Iterating\n";
        $func->($count);
   }
};
[download]

Of course, this is most likely inconvient to have to do this. Fear not! Currying to the rescue! Just do this:

my $counter = sub { $anon->($anon, shift) };
[download]

Hope this helps :)

The proper word is recursive, not iterative. Iterative means something else.

The error occurs because the my hasn't occured at the time where $anon is used. (Assignments are processed right to left.) Therefore, the sub uses the package variable $main::anon. Cause the my to occur first by seperating the my from the assignment:

my $anon;
$anon = sub {
   my $count = shift;
   if ($count--) {
        print "Iterating\n";
        $anon->($count);
   }
};

$anon->(4);
[download]

Update: Elaborated on the problem.

That's a guaranteed memory leak. You'll need to Scalar::Util::weaken $anon at some point to break the closure's circular reference.

aye. Refer to the posts by demerphq and stvn for solutions that don't leak.

The error occurs because the my hasn't occured at the time where $anon is used. (Assignments are processed right to left.)

Not exactly; the problem isn't the run-time effect of my not having occurred, it's with the compile-time effect.

my() "returns" (not exactly, since it's a declarator, not a function) the new lexical and that "returned" SV can be used in the current statement, but for purposes of compiling other mentions of the lexical of that name, the lexical's scope only begins with the following statement.

This can be seen with

perl -we'$foo = 2; print((my $foo=4),$foo)' </c> printing 42, not 44.

And everyone is going to have to learn the other way for perl 6 because lexicals spring into existence immediately upon being parsed (not the whole statement, just the variable). So, in this code:

my $x = $x + 5;
[download]

Both $x refer to the same storage location (the same variable). To get the perl5 behavior you have to say something like:

my $x = $OUTER::x + 5;
[download]

duff

Closures that enclose themself represent a reference cycle which is a.k.a. a memory leak. If you need a self referencing sub you should localize a glob to do it. Ie:

local *recursive=sub { ... recursive(...); };
[download]

This keeps the self references "soft" and means that when it goes out of scope the sub will be freed. Doing it via lexicals is not correct

my $recursive;
$recursive=sub{ ... $recursive->(...); };
[download]

as it will leak. (Meaning the sub referenced by $recursive will not be freed until global destruction.)

---
$world=~s/war/peace/g

See also Sub::Recursive which handles all that for you in a clean way.

use Sub::Recursive;

my $recursive = recursive { ... $REC->(...) ... };
[download]

my $anon;

$anon = sub {
   my $count = shift;
   if ($count--) {
        print "Iterating\n";
        $anon->($count);
   }
};
[download]

Me too: sub getting reference to itself : generic way