G'day TIOOWTDI,

Welcome to the Monastery.

You actually want to capture zero or more instances of '(\s*\d+\s*)'; i.e. '((?:\s*\d+\s*)*)'.

Your OP code:

$ perl -E '
    my $re = qr{(\w+)(\s*\d+\s*)*};
    my $str = "a 1 2 3 b 4 5 6";

    while ($str =~ /$re/g) {
        say "$&: $1 $2";
    }
'
a 1 2 3 : a 3
b 4 5 6: b 6
[download]

With fixed regex:

$ perl -E '
    my $re = qr{(\w+)((?:\s*\d+\s*)*)};
    my $str = "a 1 2 3 b 4 5 6";

    while ($str =~ /$re/g) {
        say "$&: $1 $2";
    }
'
a 1 2 3 : a  1 2 3
b 4 5 6: b  4 5 6
[download]

Named captures don't change the regex logic. The start of capture groups changes from '(' to '(?<name>'; and, accessing values changes from '$N' to '$+{name}'.

$ perl -E '
    my $re = qr{(?<letter>\w+)(?<digit>(?:\s*\d+\s*)*)};
    my $str = "a 1 2 3 b 4 5 6";

    while ($str =~ /$re/g) {
        say "$&: $+{letter} $+{digit}";
    }
'
a 1 2 3 : a  1 2 3
b 4 5 6: b  4 5 6
[download]

It's not specifically part of your question; however, it occurs to me that you might not want to capture all that excess leading and trailing whitespace. Compare these:

$ perl -E '
    my $re = qr{(\w+)((?:\s*\d+\s*)*)};
    my $str = "a 1 2 3 b 4 5 6";

    while ($str =~ /$re/g) {
        say "|$&|: |$1| |$2|";
    }
'
|a 1 2 3 |: |a| | 1 2 3 |
|b 4 5 6|: |b| | 4 5 6|
[download]

$ perl -E '
    my $re = qr{(\w+)\s+((?:\s*\d+)*)};
    my $str = "a 1 2 3 b 4 5 6";

    while ($str =~ /$re/g) {
        say "|$&|: |$1| |$2|";
    }
'
|a 1 2 3|: |a| |1 2 3|
|b 4 5 6|: |b| |4 5 6|
[download]

— Ken

from the original discussion on Reddit:

Okay but I also just want a list of each of the matches so I can parse them separately. Think attributes in html, a tag can have multiple, and being able to handle each individually is useful

...

that still doesn't give me

(a => [1, 2, 3], b => [4, 5, 6]) where in my analogy the letters are the html tags and the numbers are the attributes

your answer with "1 2 3" in a string has already been given multiple times.

BTW: The OP's moniker is Timegazer not Onion

• if you use the /$re/g modifier in scalar context it will continue where the last pos stopped. Like this you can collect all digits in a while loop. You might need \G to anchor the matches.
• embedding (?{CODE}) constructs right after a temporary match can be used to collect those matches in an array without a surrounding loop.

I'm mobile now and can only provie code examples by the night. (But others will be faster )

For details see perlretut and other linked docs

Edit

https://perldoc.perl.org/perlretut#Global-matching

https://perldoc.perl.org/perlretut#A-bit-of-magic:-executing-Perl-code-in-a-regular-expression

Here the promised code for both approaches, using named captures.

NB: Using the same precompiled regexes each time.

use v5.12;
use warnings;
use Data::Dump;

my $re_start = qr{(?<start>\w+)\s*};

my $re_repeat = qr{\s*(?<repeat>\d+)\s*};

my $str = 'a 1 2 3 b 4 5 6';

while ( $str =~ /\G$re_start/g ) {
      print "$+{start}: "; 
      while ( $str =~ /\G$re_repeat/gc ) {
            print "$+{repeat} ";
      }
      print "\n";
}


my @res;
$str =~ /
            (?:
                $re_start
                (?{ push @res, $+{start} })

                (?:
                    $re_repeat
                    (?{ push @res, $+{repeat} })
                )*
            )*
        /gx;

dd \@res;
[download]

a: 1 2 3 
b: 4 5 6 
["a", 1, 2, 3, "b", 4, 5, 6]
[download]

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

edit

• https://perldoc.perl.org/perlretut#Global-matching
• https://perldoc.perl.org/perlretut#A-bit-of-magic:-executing-Perl-code-in-a-regular-expression

to meet these explicit requirements, here an altered version.

NB: how similar those solutions look like in the end...

use v5.12;
use warnings;
use Data::Dump;

my $str = 'a 1 2 3 b 4 5 6';

my $re_start  = qr{(?<start>\w+)\s*};
my $re_repeat = qr{\s*(?<repeat>\d+)\s*};


# --- approach 1 with \G and /gc 
my @res1;
while ( $str =~ /\G$re_start/g ) {
      push @res1, [$+{start}]; 
      while ($str =~ /\G$re_repeat/gc) {
            push @{ $res1[-1] }, $+{repeat};
      }
}
dd \@res1;

# --- approach 2 with embedded (?{CODE})
my @res2;
$str =~ /
            (?:
                $re_start
                (?{ push @res2, [$+{start}] })

                (?:
                    $re_repeat
                    (?{ push @{ $res2[-1] }, $+{repeat} })
                )*
            )*
        /gx;
dd \@res2;
[download]

output

[["a", 1, 2, 3], ["b", 4, 5, 6]]
[["a", 1, 2, 3], ["b", 4, 5, 6]]
[download]

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

Is there something wrong with the (obvious?) just surround both groups with another outer set of parens (which then shifts the numerics down by one)? Should work with a named mark as well.

my $re = qr/(?<whole_enchilada> (?<Letter>\w+) (?<Digit>\s*\d+\s*)* )/
+x;
[download]

Edit: NVM, misread what was being asked. You could wrap the second set of parens outside the quantifier I believe but that's not going to preserve the separate matches. ENOCAFFEINE . . .

Edit 2: Playing with %- and friends I'm not finding anything obvious. The other suggestion about using minor ebil like embedded code pushing to an array sounds like the most promising.

#!/usr/bin/env perl
use 5.034;

use YAML::XS qw( Dump );

my @digits;
my $re = qr{(?{@digits=()}) 
            (?<letter>\w+)
            ( (?<digit> \s* \d+ \s*)(?{push @digits, $+{digit}}) )* }x
+;

my $str = 'a 1 2 3 b 4 5 6';

while( $str =~ m{$re}g ) {
  say qq{$&: '$1'\t}, join( q{|}, @digits );
}

exit 0;

__END__
oscar:~  1027> perl refoo.plx
a 1 2 3 : 'a'    1 |2 |3
b 4 5 6: 'b'     4 |5 |6
[download]

Is using Regexp::Grammars really the only way to do it? Seems like overkill...

daxim gives BOTH solutions

Regexp::Grammars , its nice

RFC: A walkthrough from JSON ABNF to Regexp::Grammars