(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";
}
[download]

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?
[download]

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.¹ 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.

---

¹ 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