#normal sub
sub foo { 
  return join ("#",@_);
}

{ #Anon block for static vars to live in.
  my $join="-";
  sub bar {
    my $ret=join($join,@_);
    $join=($join eq "-") ? ":" : "-";
    return $ret;
  } 

} # End static block

print foo(1..10),"\n";
print foo(1..10),"\n";
print bar(1..10),"\n";
print bar(1..10),"\n";
print bar(1..10),"\n";
__END__
1#2#3#4#5#6#7#8#9#10
1#2#3#4#5#6#7#8#9#10
1-2-3-4-5-6-7-8-9-10
1:2:3:4:5:6:7:8:9:10
1-2-3-4-5-6-7-8-9-10
[download]

:-)

PS: If memory serves me right I believe that the anon block should become a BEGIN block under some circumstances (mod_perl maybe?). I seem to recall something by tye on the matter but I dont recall the details, and I cant find the post in question.

Yves / DeMerphq
---
Writing a good benchmark isnt as easy as it might look.

There are lots of cases where the BEGIN fixes problems. mod_perl is one. Several others boil down to variations on this problem:

#!/usr/bin/perl -w
use strict;

print "Starts out false: ", boolToggle(), $/;
print "Then is true: ", boolToggle(), $/;
print "Then false: ", boolToggle(), $/;
print "Then true: ", boolToggle(), $/;

# BEGIN # Remove first "#" from this line to fix bug.
{
    my $static= 1;
    sub boolToggle {
        $static= $static ? 0 : 1;
        return $static;
    }
}

print "Then opposite of last time: ", boolToggle(), $/;
[download]

which produces:

Starts out false: 1
Then is true: 0
Then false: 1
Then true: 0
Then opposite of last time: 0
[download]

Trying to topologically sort your subroutine declarations to avoid this problem is probably not a good solution.
        - tye (but my friends call me "Tye")

I'd solve this using a class. The object instantiated would be initialized with a given value by the new() method (or by a default value) and then the value would be manipulated with a method, that would apply the required changes to the value and return the updated value.

I would also ask myself the question if I should implement this as a Singleton class, all depending upon the needs at hand.

Of course there's always TIMTOWTDI and you could try something like this ...

{
    my $lex_sub;
    sub coro {
        my @lexvar = @_;
        $lex_sub = sub {
            print pop @lexvar, $/;
            return scalar @lexvar;
        } if not defined $lex_sub;
        $lex_sub->();
    }
}
my @words = qw(foo bar baz quux);
coro() while coro(@words);

__output__

quux
baz
bar
foo
[download]

_________
broquaint

#!/usr/bin/env perl

use strict;

sub precompare {
    my $name = shift;
    my ($caller) = caller;
    $name = "$caller\::$name";
    my @mem;
    no strict 'refs';
    if (*{$name}{CODE}) {
        warn "Redefining sub $name\n";
    }
    *{$name} = sub {
        my $x = shift;
        my $y = shift;
        push @mem,$y if($x eq $y);
        return @mem;
    };
};

precompare 'compare';
[download]

Hmm. While the idea is interesting the implementation scares the willies out of me. Lets hope that a real version would check to make sure that $name is of a legal value. Imagine what would happen if $name was 'precompare' for a simple example. Or open()....

Yves / DeMerphq
---
Writing a good benchmark isnt as easy as it might look.

I suppose it could refuse to redefine a sub that already exists, instead of just complaining. On the other hand, "package::open" wouldn't trounce "CORE::open", it would just lead to unexpected behavior (or maybe a warning). And if you redefined "precompare", you wouldn't be able to use it any more. But then again, if you did this, you probably wouldn't deserve to use "precompare" in the first place... Perl has a lot of chainsaws, and it's great fun to use them with reckless abandon.

/s