The reason (?{}) and (??{}) aren't used to often is that they are extremely powerful, and most data parsing simply doesn't need that kind of power (or, when it does, most people will turn to Parse::RecDescent). However, I've found the code expression abilty to be quite helpful in employing a few slick tricks, such as:

1. Conditional Insert: (??{(cond) ? yes : no})

   I'm not talking about (?(cond) yes|no), of course; (?(cond) yes|no) will only take a backreference or a zero width assertion as its condition. (??{(cond) ? yes : no}) will similary cause the appropriate pattern to be inserted based on the evaluation of the condition; however, the condition is no longer limited. This is useful in such cases where you don't want to fail if are using the (?(cond)yes) of (?cond), or are mucking with much weirder other things... (see my homenode for an example)

2. Partial Backreferences: (??{substr($string_that_is_matched_against,$+[$#+]-1,1)})

   The snippet above will insert the last character was matched when the regex hits that point. Above is a general case, useful if you are playing with recursion; if you know $DIGIT, you can always do:

   (??{substr($DIGIT,-1)}
   [download]

3. Dynamically Building Character Classes: (??{'[\Q$letters\E]*'})

   Variables normally can't be interpolated within character classes. With (??{}), now you can.

4. Matching/extracting arbitrarily nested elements with recursion: (??{$compiled_regex})

   Like the anonymous monk already said, (??{}) is a necessity in matching nested sets of paren/brackets/etc if you don't want to go crawling through the string C-style. I go into more detail using a less basic example than the one in perlre here.

I have other "interesting" regex on my homenode, and many involve our friends (??{}) and (?{}). Take a look if you don't feel like sleeping well tonight.

A few corrections:

1. The (?(...)true|false) can also take a (?{ code }) block as its condition.

3. Uh, /[\Q$foo\E]/ works for me. The problem comes when you want to employ variables that are created as the regex matches (like the digit variables). Then it comes in handy. For example, /.(??{ "[^\Q$&\E]" })*/s finds a string of characters with no repeats.

You can see examples of code assertions in my book, whenever the hell I finish it.

_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker, who'd like a job (NYC-area)
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

Regarding 1: That most certainly is an undocumented feature. According go perlre:

(?(condition)yes-pattern|no-pattern)
(?(condition)yes-pattern)

Conditional expression. (condition) should be either an integer in par
+entheses (which is valid if the corresponding pair of parentheses mat
+ched), or look-ahead/look-behind/evaluate zero-width assertion.
[download]

Update: I saw, and read that phrase; however, my brain hates me and skipped processing it correctly ;(

(??{}) is handy in matching nested sets of paren/brackets/etc without crawling through the string C-style, but not a necessity.

True; but rolling with your flow, regexes themselves aren't really a necessity - only something that happens to be handy for when when you don't feel like crawling through a string C-style.

Very nice! I especially like the partial backreferences.
It is possible to dynamically build character classes the ordinary way:

foreach my $char (a..d) {
   print "bbb matches $char\n" if "bbb" =~ /[$char]/;
}
[download]

prints

bbb matches b
[download]

Thanks for expanding my horizons!
-Mark