I'd suggest Super Search. Which will basically show that AnomalousMonk is the local expert on the subject :P. After a quick browse, I have extracted two bits of interresting (to me) information. First (*SKIP) and (*FAIL) can be used for something that quacks like variable length look behind assertions, as discussed here. Second, (*FAIL) is identical to (?!), and one is actually compiled to the other.

I find this interesting because I have actually never used any of the control verbs - I remember having a vague understanding of what they do, and how to use them, but not why I would need them - while I have used look-around assertions (mostly look ahead) on several occasions and have a more intuitive understanding of them.

On the "variable length look behind assertion" case though, a far simpler solution has been made available with \K. This may be one reason why (*SKIP) and (*FAIL) aren't very common, but might also be another gateway to understanding what they do

\K is the basis for a variable length positive look behind assertion. The case discussed here implements a variable length negative look behind assertion, which in Perl must always be emulated in some way (ATM).

---

Give a man a fish:  <%-{-{-{-<

Ahem, yes. I failed to see that. Thanks pointing that out.

On a completly far-fetched note, now that I think I understand the (*SKIP)(*FAIL) pattern, it seems to me that it only covers the subset of negative look behind assertions that do not come after any character has been matched. For example: /^(.{5})+(?<!ab*c)d/ (which is the same as matching /d(?!cb*a)(.{5})+$/ on the reverse string) can't be rewritten using the (*SKIP)(*FAIL) pattern (AFAICT). I'm sure this is a problem people stumble upon all the time :P

    my $string = <>;
    my %substrings;
    $string =~ /(.+)(?{ $substrings{ $1 } = 1 })(*FAIL)/;
[download]

    / (\b\d+\b) .*? (\b\d+\b) (?{ $count += $1 > $2 }) (*FAIL) /x;
[download]

Also once I used '(?{})' with '(*FAIL)' simply for traversing all characters of the string.


    /.(?{ do_smth( $& ) })(*FAIL)/ for @lines;
[download]

This part:

    /.(?{ do_smth( $& ) })(*FAIL)/
[download]

is similar to:

    do_smth( $& ) while /./g;
[download]

, but it can not(?) be combined with 'for' into one short expression like:

    do_smth( $& ) while /./g for @lines;  # syntax error
[download]

Instead I should write:

    do{ do_smth( $& ) while /./g } for @lines;
[download]

Another variant here was to concatenate all lines: my $concatenated_lines = join $some_concatenator, @lines. And then simply match. But imagine if the regex is more complex and can accidentally match a concatenator as well.
And another alternative here was to use eval within non-destructive substitution:

    s/./ do_smth( $& ) /ger for @lines;
[download]

Note modifiers: e - for eval, and r - for non-destructiveness.
But imagine do_smth function returning long strings (e.g. ( ( ord $& ) % 2 ? $odds : $evens ) .= $&) and it could possibly(?) slow down process.