Beefy Boxes and Bandwidth Generously Provided by pair Networks
good chemistry is complicated,
and a little bit messy -LW
 
PerlMonks  

Re: Multi-stage flip-flop?

by LanX (Saint)
on Dec 11, 2014 at 14:31 UTC ( [id://1110044]=note: print w/replies, xml ) Need Help??


in reply to Multi-stage flip-flop?

would this dispatcher like syntax be OK for you?

till ( - /match0/ => \&doOtherProcessing, - /match1/ => \&doStage1, - /match2/ => \&doStage2, - /match3/ => \&doStage3, )

of course you are also free to write something like

till ( - /match0/ => sub { print "default Processing" }, - yadda yadda ... )

please note that the minus is obligatory to:

  • enforce scalar context around the /match/
  • avoid "empty" values which are ignored in lists³

Furthermore you'll need to bind the state¹ of till() to it's position, i.e. using caller to determine filename and line number of invocation.

Cheers Rolf

(addicted to the Perl Programming Language and ☆☆☆☆ :)

¹) e.g. the $fn here

²) Consequently you shouldn't use two till()'s within the same line, otherwise they'll share the same state.

³) minus transforms true => -1 , false => 0

Replies are listed 'Best First'.
Re^2: Multi-stage flip-flop? ( till() - proof of concept)
by LanX (Saint) on Dec 11, 2014 at 23:52 UTC
    Proof of concept:

    use strict; use warnings; use Data::Dump; { my %state; sub till { my @phases=@_; my ($file,$line)= (caller)[1..2]; my $state = \$state{$file,$line}; $$state //= 0; $phases[1+$$state]->($_); if ($phases[$$state]) { $$state += 2; $$state %= @phases; } } } sub doStage1 { print "1: ",shift } sub doStage2 { print "2: ",shift } sub doStage3 { print "3: ",shift } sub doOtherProcessing { print "*: ",shift } while (<DATA>){ till ( - /for/ => \&doOtherProcessing, - /their/ => \&doStage1, - /fruit/ => \&doStage2, - /lazy/ => \&doStage3, ); } __DATA__ now is the time for all good men to come to the aid of their party. Time flies like an arrow fruit flies like a banana. The quick red fox jumps over the lazy brown dog. Etaoinshrdlu.

    output:

    *: now is the time *: for all good men to 1: come to the aid of 1: their party. 2: Time flies like an arrow 2: fruit flies like a banana. 3: The quick red fox 3: jumps over the lazy *: brown dog. *: Etaoinshrdlu.

    Cheers Rolf

    (addicted to the Perl Programming Language and ☆☆☆☆ :)

      After refining my code from Re^6: Multi-stage flip-flop?, my proof of concept where conditions are only evaluated in the corresponding state.

      To do: Add tests for code and scalar based conditions.

        Your concept of passing the condition only works when testing a global var like $_ and typechecking is vulnerable in edge cases.¹

        I think my concept is more robust and any boolean test can be used.

        Sometimes less is more.

        use strict; use warnings; use Data::Dump; { my %state; sub till { my @phases=@_; #dd \@_; my ($file,$line)= (caller)[1..2]; my $state = \$state{$file,$line}; $$state //= 0; $phases[1+$$state]->(); if ($phases[$$state]) { $$state += 2; $$state %= @phases; } } } while (my $var = <DATA>){ till ( - ($var =~ /for/) => sub { print "*: $var" }, - ($var =~ /their/) => sub { print "1: $var" }, - ($var =~ /fruit/) => sub { print "2: $var" }, - ($var =~ /lazy/) => sub { print "3: $var" }, ); } __DATA__ now is the time for all good men to come to the aid of their party. Time flies like an arrow fruit flies like a banana. The quick red fox jumps over the lazy brown dog. Etaoinshrdlu.

        out

        *: now is the time *: for all good men to 1: come to the aid of 1: their party. 2: Time flies like an arrow 2: fruit flies like a banana. 3: The quick red fox 3: jumps over the lazy *: brown dog. *: Etaoinshrdlu.

        Cheers Rolf

        (addicted to the Perl Programming Language and ☆☆☆☆ :)

        ¹) What if a test returns a reference for true? Enforcing negation with a unitary minus solves this issue.

        (Updated to add explanation of the error in the scalar test.)

        I added tests for code references and scalars as conditions:

        sub c3 { print "Evaluating condition 3\n"; /gamma/; } sub c4 { print "Evaluating condition 4\n"; /omega/; } while (<DATA>) { chomp; mff(qr/alpha/ => \&s1, qr/beta/ => \&s2, \&c3 => \&s3, c4() ) or print "*:$_\n"; }

        In the above, a code ref to c3 is passed. c4, however, is called and its result, a scalar, is passed.

        The results:

        Evaluating condition 4 *:This is Evaluating condition 4 1:the alpha Evaluating condition 4 1:but not Evaluating condition 4 1:the omega Evaluating condition 4 2:Now the beta Evaluating condition 4 Evaluating condition 3 2:progressing to Evaluating condition 4 Evaluating condition 3 *:the gamma Evaluating condition 4 *:and finally Evaluating condition 4 *:the omega Evaluating condition 4 *:Did this work?

        c3, which was passed as a code ref, was evaluated only in state 2, as expected. So, conditions passed as code refs do work.

        c4, because it is called before calling mff, is evaluated every iteration, as expected. However, there is an error: mff transitioned to the "inactive" state too soon.

        Update: changing the call to c4 to !!c4() "fixed" the test. The !! imposes scalar context on the call to c4. (It also "imposes" boolean context. Note that +c4() or -c4() would also have worked.)

        Note: LanX raises a valid point: "What if a test returns a reference?" That depends on what the reference points to. If a scalar, then the scalar value is tested. If a regex, it is evaluated against $_. If code, it is evaluated and its return value tested. If another reference, that reference is treated as a scalar.1 If anything else, mff croaks with the message "Unsupported type".

        I think flip-flop ( .. ) handles refs to scalars, regexen and code the same. Given that ref(ref(any)) eq 'SCALAR', I suspect it handles refs to refs the same as scalars. Refs to anything else, I don't know. More testing needed.

        ---

        1 I tested print ref(ref(1)) and print ref(ref(qr/foo/)) and print ref(ref(sub { print 1; })) and several others. Each time, the result was SCALAR

        The CODE part shouldn't work left from a fat comma.

        Keys are always a stringifyed!

        Cheers Rolf

        (addicted to the Perl Programming Language and ☆☆☆☆ :)

Re^2: Multi-stage flip-flop?
by RonW (Parson) on Dec 11, 2014 at 16:46 UTC

    Can a "bare" regex be used like that? I would have thought it would need quoting.

    So maybe:

    till ( qr/match0/ => \&doOtherProcessing, qr/match1/ => \&doStage1, )
      That's completely different, qr// returns a regex and not the result of a boolean test.

      Cheers Rolf

      (addicted to the Perl Programming Language and ☆☆☆☆ :)

        How else would till control which condition got evaluated?

        If till were actually built in to Perl, it could control control evaluation.

        But, if it was built in, then it could impose scalar context on the conditions with out needing the - in front.

Log In?
Username:
Password:

What's my password?
Create A New User
Domain Nodelet?
Node Status?
node history
Node Type: note [id://1110044]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this?Last hourOther CB clients
Other Users?
Others studying the Monastery: (7)
As of 2024-03-28 16:12 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    No recent polls found