not without reimplementing it

> and now it looks:

my %matches = %+;
sub(\%matches);
[download]

why not just

func( { %+ } );

this will pass the hashref of a flat copy, without messing with the globally tied %+

update

demo in debugger

  DB<18> use Data::Dumper

  DB<19> sub func { say Dumper \@_}

  DB<20> 'ABC' =~ /(?<a>\w)(?<b>\w)(?<c>\w)/; func({%+})
$VAR1 = [
          {
            'a' => 'A',
            'b' => 'B',
            'c' => 'C'
          }
        ];
[download]

NB: if you are only passing the named captures, why not just flattening %+ to a list?

  DB<22> sub func { my %matches = @_; say Dumper \%matches}

  DB<23> 'ABC' =~ /(?<a>\w)(?<b>\w)(?<c>\w)/; func(%+)
$VAR1 = {
          'a' => 'A',
          'b' => 'B',
          'c' => 'C'
        };
[download]

edit

s/sub/func/ , since sub is a keyword

Thank you! I've forgotten this:

func( { %+ } );
[download]

It's great solution.

As it shows in perlvar if you use English there's also %{^CAPTURE} and %{^CAPTURE_ALL} respectively:

## Being lazy and using the Mojo "ojo" oneliner for it's dumper r()
$ perl -Mojo -MEnglish -E '$_ = q{foo = bar};m{(?<name>\w+) \s* = \s* 
+(?<value>.*) $}x; say r(\%{^CAPTURE})'
{
  "name" => "foo",
  "value" => "bar"
}
[download]

That being said (IMHO) eliminating every single magic variable isn't really getting you that much of a gain for the extra typing you're setting yourself up to do (${^CAPTURE}{name} vs $+{name}). Some things are just idiomatic perl and going out of your way to make things more cumbersome to type for (again, IMHO) minor "readability" improvements isn't really helpful.

Edit: Or if you read perlvar more carefully it mentions Tie::Hash::NamedCapture which lets you create a named alias which was exactly what you'd asked for. Derp. Since this lets you give the tied hash a semantically meaningful name yourself I'd say that's marginally more valid, but still a bit of . . . not overkill, but maybe more effort than it's worth for a (small) benefit over $+{foo}.

$ perl -Mojo -MTie::Hash::NamedCapture -E '$_ = q{foo = bar};m{(?<name
+>\w+) \s* = \s* (?<value>.*) $}x; tie my %h, q{Tie::Hash::NamedCaptur
+e}; say r(\%h)'
{
  "name" => "foo",
  "value" => "bar"
}
[download]

> %{^CAPTURE}

is just %+ by another name° and wouldn't solve the OP's issue with it having global sideeffects, which could lead to unexpected results.

  DB<34> 'ABCD' =~ /(?<a>\w)(?<b>\w)(?<c>\w)(?<d>\w)/; $h_matches = \%
+{^CAPTURE}; say Dumper $h_matches
$VAR1 = {
          'b' => 'B',
          'c' => 'C',
          'a' => 'A',
          'd' => 'D'
        };


  DB<35> x $h_matches
0  HASH(0x2fa07f0)
     empty hash                # oh oh ...
[download]

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}

°) not an alias tho, they have different refs

Aaah I've apparently missed (as in misread) what they're looking for and why (thinking that they're objecting to the punctuation-ness). Once you mentioned that I was thinking maybe the tied version captured %+ at the point of tying but experimenting shows it's affected by the global state so no dice there.

I could maybe imagine roughing out some sort of "matching state" context object that captures (ha) all of this stuff and returns an independent instance but that's getting back along the lines of your sample in that you'd need to use something else rather than native m{} or what not.

use Hypothetical::MatchState qw( matchit );
my $match1 = matchit( $_ => $regex );
my $match2 = matchit( $other => $regex );
say $_->named( q{foo} ) for ( $match1, $match2 );
[download]

The cake is a lie.
The cake is a lie.
The cake is a lie.

So I decided to create a package to serve my needs. It's creates isolated level from %+, %-. https://metacpan.org/pod/Regex::Object

Thanks for writing this!

Personally, I think there could be a small enhancement, to be able to also create match objects without needing the regular expression, like:

my $string = 'foo foo fooo';
while( $string =~ /(fo+)/g) {
    my $match = Regex::Object->collect();
    push @matches, $match;
}
[download]

That way, the collecting of the match data is available even when I'm not running a plain match.

released v1.1 with collect method https://metacpan.org/pod/Regex::Object#collect()

Great idea! I'll think about implementation!