To get the "won't stay shared" warning, you have to have something like:

sub a {
    my $x;
    sub b { $x }
}
[download]

Since the bare block is only ever executed once, your my only ever creates one instance of the variable so it "stays shared". When a my is compiled, it declares the variable (which leaves it set to undef). When the my is executed, it initializes the variables. Executing the my a second or subsequent time creates a new instance of the variable and then initializes that. Even if you require or use a module more than once, the code for the module is only compiled and executed once (but the code for subroutines in that module could be executed more times or zero times).

The code you used would be a fine way to store module-specific results. If your block were in a different module, then it would be the module and not the caller storing them.

Updated.

It seems that my $foo only creates a place for sub up to store values between calls. Why does initializing it to 20 not have an effect?
Thanks

use strict; use diagnostics;
up();
up();
print "getfoo=",get();
{
my $foo = 20;
sub up {
    print "subup=$foo\n";
    $foo++;
sub get {$foo}
}
}

prints:

subup=
subup=1
getfoo=2
[download]

The reason is because $foo = 20 doesn't occur until after you've called all those functions.

DECLARATION occurs at compile-time. ASSIGNMENT happens at run-time. Different things. my $foo = 20 has a compile-time effect (my) and a run-time effect ($foo = 20).

For your desired action, you'd need something like:

my $foo;
BEGIN { $foo = 20 }
[download]



japhy -- Perl and Regex Hacker

Look carefully at your code... What order will each statement be executed in? The calls to up() and get() are actually executed before the initialization of $foo to 1.

In order to get the result you want, you need to make sure that the $foo = 1 line is executed before any of the subroutine calls. One way to do this is:

use strict; use diagnostics;
up();
up();
print get();
{
  my $foo;
  BEGIN { $foo = 1; }
  sub up { $foo++ }
  sub get { $foo }
}
[download]

Anyways, in addition to the other suggestions that you have been offered, I tend to use lazy memoization as follows:

{
  my $foo;

  sub up {
    unless (defined)($foo)) {
      $foo = 1;
    }
    $foo++;
  }

  sub get {
    $foo;
  }
}
[download]

up(); 
up(); 
print get(); 
BEGIN { 
my $foo = 1; 
sub up { 
        $foo++; 
sub get {$foo} 
} 
}
[download]

-- Randal L. Schwartz, Perl hacker

Note, a BEGIN block isn't necessary -- a bare block is fine as long as it is defined prior to the sub calls. Also, a BEGIN block may not always be the appropriate mechanism:

#!/usr/bin/perl -w
use strict;
use Getopt::Std;

my %opt;
getopt('n',\%opt);

BEGIN
{ 
  my $foo = $opt{n};
  sub up { 
    $foo++; 
    sub get {$foo} 
  } 
}

up(); 
up(); 
print get();
[download]

Now, if you comment out the BEGIN line above it will work as one might have expected. Not that I think this might be a common problem, but I thought it might be worthwhile to highlight the difference.