sub foo {

  my $bar =     sub {
        my ($i) = @_;

        push @arrb, $arra[$i];
        
  };

  $bar->($#arra);

  ...
}
[download]

Note that the above leaks if the anon sub accesses $bar. That would be the case if the anon sub is recursive, for example. I find the following simpler, and it doesn't leak.

sub foo {
   ...

   local *bar = sub {
      ...
   };

   bar(...);
}
[download]

The above works

No, it doesn't. Call foo twice and check the results. (It always returns undef after the first call.)

Just want to add one point to make this observation complete: this issue can be fixed by doing what the anonymous monk suggested above.

However, the best is to code in a simple and straight forward manner. That's the principle.

Peter (Guo) Pei

Good code is usually straight forward, and this code is misleading in couple of ways:

1. Visually, bar seems to be only available inside foo. But that's not true, bar can actually be called outside of foo.
2. Make it even worse, when bar is called outside of foo, it does not do what's expected any more.

Actually, I disagree. The provided code is actually visually very helpful, as it leads (mind you, leads, not misleads) the reader to think that bar() makes sense in the context of foo().

From OOP we know that Perl doesn't protect methods and variables. Perl would much rather that you didn't come into its home uninvited than put locks on its doors. The reader of the code should simply not call bar() from outside foo().

That said, the suggestion to convert bar() into an anonymous sub is a good one. That makes things even clearer.

--

when small people start casting long shadows, it is time to go to bed

The provided code is actually visually very helpful, as it leads (mind you, leads, not misleads) the reader to think that bar() makes sense in the context of foo().

Maybe that code documents that its author intended such a thing, but to an experienced Perl programmer, I suspect that the code instead reads as if the author doesn't know how lexicals and sub declarations work in Perl.

The ... code [of the OP] ... leads ... the reader to think that bar() makes sense in the context of foo().

But does the code lead the reader to think that foo() does not make sense in the context of bar()? (See ikegami's Re: a sub within a sub -- revisiting.) If the code does not alert the reader to the subtle (side?) effect pointed out in that reply, it is not helpful and should either be heavily commented or another, more straightforward approach should be chosen to achieve the same effect. (Of course, this assumes the effect is intended in the first place!)