That could be achived by using multiple regexen instead of alternation:

#!/usr/bin/perl
use strict;
use warnings;
use 5.012;
# #926110

my $regex1 = qr/foo\d+/;
my $regex2 = qr/bar\S+?/;

my @string = qw(foo17 barABC nomatch);

for my $string(@string) {
    if ($string =~ m/($regex1)/ && $regex1 =~ /(.*)/s) {
        say "$1 when string is \"$string\"";
    } elsif  ( $string=($regex2) && $regex2 =~ /(.*)/s ) {
        say "$1 when string is \"$string\"";
    } else {
        say "no match on $string";
    }
}
[download]

(?-xism:foo\d+) when string is "foo17"
(?-xism:bar\S+?) when string is "barABC"
(?-xism:bar\S+?) when string is "nomatch"
[download]

Update: Or, better (simpler and more info in output):

hashbang, strict, warn, etc...

my $regex1 = qr/foo\d+/;
my $regex2 = qr/bar\S+?/;

my @string = qw(foo17 barABC this-has-no-match);

for my $string(@string) {
    if ($string =~ m/($regex1)/) {
            say "matched part of \"$string\" is $1 when  regex is \"$r
+egex1\"";
        next;
    } elsif ( $string=~ m/($regex2)/ ) {
        say "matched part of \"$string\" is $1 when regex is \"$regex2
+\"";
        next;
    } else {
        say "no match on $string";
    }
}
[download]

matched part of "foo17" is foo17 when  regex is "(?-xism:foo\d+)"
matched part of "barABC" is barA when regex is "(?-xism:bar\S+?)"
no match on this-has-no-match
[download]

You can't, and it doesn't make much sense to do so. Maybe you want something like this:

    my $matched_pattern;
    if (/$regex/) {
        $matched_pattern = $regex;
    };
[download]

If you're really bent on filling $1 with an arbitrary string, you can do so by doing:

    my $regex = qr/foo/;
    $regex =~ /^(.+)$/ms; # fill $1 with $regex
    print $1;
[download]

This does not make sense to me, so most likely I misunderstood your question. If you want something else, please tell us the output you want.

my $regex = 'foo\\d+|bar\S+?';
...
m/($regex)/;
[download]

if (m/($regex)/) {
    print $regex;
}
[download]

prints the pattern that matched the text in $1.

But why would you want that? It might be an XY Problem, and a better solution might exist.

if ($_ =~ m/($regex)/ && $regex =~ /(.*)/s) {
    ... Now $1 will contain $regex ...
}
[download]

Perhaps you are trying to see which of the two alternations matched. I wonder if this would be close enough.

$ perl -E '
> $rx = qr{(?x)
>    (
>    foo\d+(?{say q{matched foo\d+}})
>    |
>    bar\S+?(?{say qq{matched bar\S+?}})
>    )
>    };
> q{abcfoo44fred} =~ $rx && say qq{captured $1};
> q{barbell} =~ $rx && say qq{captured $1};
> q{xyz} =~ $rx && say qq{captured $1};'
matched foo\d+
captured foo44
matched bar\S+?
captured barb

$
[download]

I hope this is helpful.

Hi John

That's exactly what I needed!! Thanks a lot for your help!!

my $matching_pattern = /$pattern/ && $pattern;
[download]

This only works if there are no capturing parenthesis:

#!/usr/bin/perl

use v5.12;
use warnings;
use strict;

my @alt = (
    qr/foo\d+/,
    qr/bar\S+?/,
);
my $re = join '|', map qr/($_)/, @alt;

for my $word (qw[foofoo2010 subarashii bowwowmeow]) {
    my $_ = $word;
    if (s/$re/($+)/) {
        say "$word => $_: $alt[$#- - 1]";
    } else {
        say "$word: NO_MATCH";
    }
}
[download]

This is the output:

foofoo2010 => foo(foo2010): (?-xism:foo\d+)
subarashii => su(bara)shii: (?-xism:bar\S+?)
bowwowmeow: NO_MATCH
[download]

use strict;
use warnings;
$\="\n";


my %sp= (
     foo => 'foo\d+',
     bar => 'bar\S+?'
    );

my $regex='§foo§|§bar§';    # template

$regex=~s/§(\w+)§/(?<$1>$sp{$1})/g;

#print $regex;

my $str="  foo15  ";

if ($str =~ m/$regex/) {
  while ( my( $name, $pos) = each %+ ) {
    print "$sp{$name} matched" if $pos;
  } 
}
[download]

Rubbish. The keys of %+ gives you the names of the capture group, the values give you the part of the string that's matched. It doesn't give you the (sub)pattern.

Re-Rubbish! It's a very good advice.

Associating the name of the capture group to the subpattern solves the problem.

Cheers Rolf

Hi,

sadly, I have no access to a more recent perl version than the 5.8.8, so I can't use no named grouping within regex's. Thanks though for the advice!