in reply to Re^4: flip-flop flop
in thread flip-flop flop

The main reason is that implicit state that must be resetted explicitly is a bad idea. Especially if you compare it to a lexical variable, which provides state explicitly, and is resetted implicitly at the end of the scope.

For example if an exception is thrown before you do the reset, the next call of your function will return wrong results.

And what if there are multiple flip-flops in scope? How do you control which one is reset?

Perl 6 - second systems done right

Replies are listed 'Best First'.
Re^6: flip-flop flop
by morgon (Priest) on Mar 30, 2012 at 13:41 UTC
    I agree with your opinion regarding explicitely resetting an implicit state, nevertheless having such a hack (ugly as it would be) available would at least allow to use the flip-flop that is (at least to me) pretty much useless as it is.

    What I would wish for is a flip-flop that is tied to it's lexical scope and gets reset when control leaves the scope.

    As (for me at last) this is such a natural requirement that I assume the fact that it is not implemented probably means there would be other problems with such an approach...

[reply]
      What I would wish for is a flip-flop that is tied to it's lexical scope and gets reset when control leaves the scope.

      Such a system would not work, since { $_ eq $look_for .. 1 } is an anonymous subroutine, which also has a lexical scope on its own. So with your proposal, the flipflop would be reset after each invocation.

      The same problem comes up for the most common use case, which is in oneliners like 

      perl -ne 'print if /regex1/../regex2/'

      [download]

      where the -n flag creates a while-loop, and thus an implicit lexical scope, around the flipflop.

      A better approach (but harder to explain) would be clone the flipflop along with all other closures when the outer scope is entered.

      Let me try to explain that with a small example: 

      use strict;
use warnings;
use 5.010;

sub gen_iter {
    my $a = shift;
    sub { $a++ };
}

my $it1 = gen_iter 10;
my $it2 = gen_iter 20;
say $it1->();
say $it2->();
say $it1->();
say $it2->();
__END__
10
20
11
21

      [download]

      You can see that $it1 and $it2 have different instances of the $a variable. This is implemented by cloning the lexical pad of the inner subroutine as soon as gen_iter is entered.

      So I think the most intuitive behavior would be to clone the flipflop state along with the lexical pad when the outer scope is entered.

      But I guess that the flipflop operator isn't used often enough to motivate a core hacker to actually implement such a change.

      Perl 6 - second systems done right
[reply]
[d/l]
[select]
        Good point.

        I think I would want a way not to tie the flipflop to the "immediate" lexical scope, but to an enclosing scope n-levels up (so in my case tie it not to the anonymous sub, but the "blah-sub"-scope 1 level up.

        But it's probably hard to find a good syntax for that - so good-bye flip-flop...

        btw: Will there be a flip-flop in Perl 6?

[reply]

In Section Seekers of Perl Wisdom