Hello Pritesh,

Even though the variable is static, it is still only visible within the block where it was declared. In your example, the variable still exists, but inaccessible from outside the counter subroutine

Hope this helps.

Coping with Scoping

NB: this was written before state was introduced, see my for scoping rules.

jeffenstein has said why it doesn't work, I'm wondering what you're trying to achieve? Depending on that, there are several possible solutions, one would be to have the subroutine return the value of $add so you can access it outside the subroutine. Another, though less common in Perl, would be to have the subroutine modify its arguments. And although I hesitate to mention it, you could also use a global variable.

G'day pritesh_ugrankar,

Some preamble:

use 5.030;
use warnings;
[download]

$ alias perle
alias perle='perl -Mstrict -Mwarnings -Mautodie=:all -MCarp::Always -E
+'
[download]

$ perl -v | head -2 | tail -1
This is perl 5, version 32, subversion 0 (v5.32.0) built for cygwin-th
+read-multi
[download]

Here's an example of what you could have done that makes sense of the use of state (using slightly easier to follow numbers):

$ perle '
    say counter() for 1..3;

    sub counter {
        state $add;
        $add += $_ for (1..5);
        return $add;
    }
'
15
30
45
[download]

You could've also assigned the return value and used it later. This example also shows two $add variables, used in different lexical scopes, with no conflict.

$ perle '
    my $add;

    for (1..3) {
        $add = counter();
        say "... other processing here ...";
        say $add;
    }

    sub counter {
        state $add;
        $add += $_ for (1..5);
        return $add;
    }
'
... other processing here ...
15
... other processing here ...
30
... other processing here ...
45
[download]

This should do what you seem to be trying to do: (untested)

use strict;
use warnings;

sub counter {
  my @nums = (1..500);
  our $add = 0;
  for my $num (@nums) { $add += $num }
}

{
  our $add;
  say $add;
}
[download]

This uses our to establish lexical aliases to a global variable "add" briefly as needed. For a small program, or within a module, this can be a useful technique, but please be careful not make gratuitous uses of global variables across larger programs.

If you need more than one counter, objects are a better approach: (also untested)

package Acme::Sample::Counter;

sub new {
  my $class = shift;
  my $ob = (shift || 0);
  bless \$ob, $class;
}

sub count {
  my $self = shift;
  $$self += (shift || 1);
}

sub read {
  my $self = shift;
  return $$self;
}
[download]

Used like so:

my $counter = new Acme::Sample::Counter ();
$counter->count;      # add 1
$counter->count(10);  # add 10
say $counter->read;
[download]

Note however, that $counter->count(0) adds 1! Think about why this is so.

ADD_COUNTER_CLOSURE:
{
  # $add is not accessible outside of closure, but
  # you do the 'getter', "add" which has access to $add
  my $add = 0;
  sub counter {
    my @nums = (1..500); 
    for my $num(@nums) { $add += $num }
  }
  
  # getter
  sub add {
    return $add;
  }
}

# $add is not accessible directly here, must use add subroutine

my $add = add;
print qq{$add\n};

# increment $add via closure()
counter();
$add = add;
print qq{$add\n};
[download]

Output:

0
125250
[download]

I had an idea when you used the pre-state closure idea: put your getter inside the context of counter, so it that $add is in scope:

use 5.030;
use strict;
use warnings;

sub counter {
    my @nums = (1..500);
    state $add = 0;
    for my $num (@nums) { $add += $num; }
    sub getter { $add } # because this sub is inside the scope of coun
+ter(), it has visibility on $add!
}

counter();
say "getter => ", getter();
[download]

Side note: be careful doing this with a my variable because some weird things can happen with nested subs referencing lexicals from the enclosing scope. Look for Variable "%s" will not stay shared in perldiag.

The cake is a lie.
The cake is a lie.
The cake is a lie.

Hi,

Thank you!! It worked!!....I have always been baffled by the "getter/setter" stuff...I still don't understand it, but still was able to run the code you wrote.

Very nice, thank you. I was going old school but now this is a lot cleaner and more concise.

Respected Monks,

Thank you for your replies. I tried the last one suggested by pryrt and it worked!!

Truly thankful that so many of you took time to reply. The perlmonks is truly a great forum.