Also, in my code the separate patterns are compiled much before the disjunction, so this is not what I’m looking for:

But that is what you get. You cannot combine the compiled forms of precompiled regexen, they must be stringified for concatenation and the result has to be recompiled. There’s no way around that.

So the last snippet is what you want. Sorry.

Btw, the stringified regexen supply their own (?:) delimitation, so all you need to do is

my $joined = do {
    local $_ = join '|', @any;
    qr/$_/;
};
[download]

As an aside, you may be interested in Regexp::Assemble.

Makeshifts last the longest.

I didn't like the use of $_ to build a pattern, just as a matter of taste. I figure if you're going to localize a variable for this, make it the auto-joiner, taking advantage of the fact that regex context is double-quotish for variable interpolation (it would make sense to me if Perl magically set $" for array interpolation):

my $joined = do {
  local $" = '|';
  qr/@pats/;
};
[download]

though I'd likely do it like this:

my $joined = qr/${\join '|', @pats}/;
[download]

---

Caution: Contents may have been coded under pressure.

You cannot combine the compiled forms of precompiled regexen, they must be stringified for concatenation and the result has to be recompiled. There’s no way around that.

There is; that is exactly what (??{$someregex}) does.

Ah! Of course.

But a quick test shows me that that too does not propagate captures from the delayed patterns to the including pattern, which is why I memorised the rule as “combining precompiled patterns requires recompilation.”

(Most of the time I build a pattern programmatically from a list involves matching one of a list of hash keys, some way or other, so capturing is always involved in some fashion.)

Thanks for the correction.

Makeshifts last the longest.

Don't you need a do there?

Nowadays = { ... } looks like a closure assignment to me because of Perl 6.

Probably not what you're looking for, but I'd be tempted, without more context of where you're using this, to try:

  use List::Util qw(first);
  my $matched = first { $var =~ $_ } @pats;
[download]

That is in fact exactly what I'm doing now. :-)

++

This is my favorite way:

my $any = do {
    local $" = '|';
    qr/@pats/;
};
[download]

use re "eval";
my @pats = ( qr/one/, qr/two/, qr/three/ );
my $joined = "(??{" . join("})|(??{", map "\$pats[$_]", 0..$#pats) . "
+})";
my $any    = qr/$joined/;
[download]

I really loathe the “join with right+left delimiter” idiom for paired delimiters. Since you don’t need a map for this, let me demonstrate that extreme to show why I don’t like it:

my $joined = "(??{ \$pats[" . join( "] })|(??{ \$pats[", 0 .. $#pats )
+ . "] })";
[download]

Uhm, oh dear.

Instead, I’d always prefer a map to put the delimiters in place before joining – it’s clearer, with less repetition of literals to boot. You’ve recognised the need for a map to clarify anyway – so take it to conclusion:

my $joined = join '|', map "(??{ \$pats[$_] })", 0 .. $#pats;
[download]

I think that looks a lot friendlier (than your code; to say nothing of my demonstration of atrocity).

Makeshifts last the longest.

I have not used that in this context, but it may do what you need.

Probably not in Perl 5. But with Pugs I already can, and would.

my @pats = /one/, /two/, /three/;
say "matched" if $string ~~ any @pats;
[download]

Then again, Perl 6 Rules have better composition, uh, rules, so there's likely a way to do it without a junction. One reason to insist is that where

$string ~~ any @pats

matches,

my $any = any @pats;
$string ~~ $any;
[download]

does not. This means that I can't use a junction and a precompiled disjunctive pattern interchangably e.g. in a given block:

given $string {
    when $any { ... } # won't work if $any is a junction
}
[download]

At least, that's how it operates now; I'd better ask on p6-l if that's the desired behavior. :-)

Update: come to think of it, it's almost certainly a pugsbug.