+------------+-----------+----------+----------+--------------+
|            |    SCALAR / VOID     |        LIST             |
| m/REGEX/   +-----------+----------+-----------+-------------+
|            |           | (groups) |           | (groups)    |
+------------+-----------+----------+-----------+-------------+
| /          | ->BOOLEAN | ->COUNT  | ->BOOLEAN | ->CAPTURES  |
| /g         | ->BOOLEAN | ->COUNT  | ->BOOLEAN | ->CAPTURES  |
+------------+-----------+----------+-----------+-------------+

##</code><code>##

use v5.12.0;
use warnings;
use Data::Dump qw/pp dd/;
use Data::Dumper;


my $time = '"2$X:1$X:0$X "';

my $str = "";

for my $X (1..3) {
    $str .= eval($time);
}

say $str;

my ($res,@res) ;

my %CTX=
  (
   VOID   => { LHS => ''      , RES => undef },
   SCALAR => { LHS => '$res =', RES => \$res },
   LIST   => { LHS => '@res =', RES => \@res },
  );


my %REGEX =
  (
   "GROUPS_NO"   => '2.:1.:0.',
   "GROUPS_YES"  => '(2.):(1.):(0.)'
  );

my %got;

my $ctxt_cnt = 0;
for my $ctx (qw/SCALAR LIST VOID/) {
    for my $groups ( map "GROUPS_$_", qw/YES NO/ ) {
        for my $mod ("","g") {
            my $LHS   = $CTX{$ctx}{LHS};
            my $REGEX = $REGEX{$groups};
            my $code  = "$LHS ( \$str =~ /$REGEX/$mod );";
            eval($code);
            my $ref   = $CTX{$ctx}{RES} ;
            my $type  = ref $ref;
            my $res =
              $type eq "SCALAR" ? $$ref :
                $type eq "ARRAY" ? [ @$ref ] :
                  undef;
            pp { context => $ctx, code => $code, mod => $mod, result => $CTX{$ctx}{RES} };
            $got{$ctx}{"MOD_$mod"}{$groups} = $res ;
        }
    }
    $ctxt_cnt++;
}

$Data::Dumper::Indent=1;
$Data::Dumper::Terse =1;

say Dumper \%got;

#pp \%got;




##</code><code>##

{
  code => "\$res = ( \$str =~ /(2.):(1.):(0.)/ );",
  context => "SCALAR",
  mod => "",
  result => \1,
}
{
  code => "\$res = ( \$str =~ /(2.):(1.):(0.)/g );",
  context => "SCALAR",
  mod => "g",
  result => \1,
}
{
  code => "\$res = ( \$str =~ /2.:1.:0./ );",
  context => "SCALAR",
  mod => "",
  result => \1,
}
{
  code => "\$res = ( \$str =~ /2.:1.:0./g );",
  context => "SCALAR",
  mod => "g",
  result => \1,
}
{
  code => "\@res = ( \$str =~ /(2.):(1.):(0.)/ );",
  context => "LIST",
  mod => "",
  result => [21, 11, "01"],
}
{
  code => "\@res = ( \$str =~ /(2.):(1.):(0.)/g );",
  context => "LIST",
  mod => "g",
  result => [23, 13, "03"],
}
{
  code => "\@res = ( \$str =~ /2.:1.:0./ );",
  context => "LIST",
  mod => "",
  result => [1],
}
{
  code => "\@res = ( \$str =~ /2.:1.:0./g );",
  context => "LIST",
  mod => "g",
  result => ["21:11:01", "22:12:02", "23:13:03"],
}
{
  code => " ( \$str =~ /(2.):(1.):(0.)/ );",
  context => "VOID",
  mod => "",
  result => undef,
}
{
  code => " ( \$str =~ /(2.):(1.):(0.)/g );",
  context => "VOID",
  mod => "g",
  result => undef,
}
{
  code => " ( \$str =~ /2.:1.:0./ );",
  context => "VOID",
  mod => "",
  result => undef,
}
{
  code => " ( \$str =~ /2.:1.:0./g );",
  context => "VOID",
  mod => "g",
  result => undef,
}
21:11:01 22:12:02 23:13:03 
{
  'LIST' => {
    'MOD_' => {
      'GROUPS_NO' => [
        1
      ],
      'GROUPS_YES' => [
        '21',
        '11',
        '01'
      ]
    },
    'MOD_g' => {
      'GROUPS_NO' => [
        '21:11:01',
        '22:12:02',
        '23:13:03'
      ],
      'GROUPS_YES' => [
        '23',
        '13',
        '03'
      ]
    }
  },
  'SCALAR' => {
    'MOD_g' => {
      'GROUPS_YES' => 1,
      'GROUPS_NO' => 1
    },
    'MOD_' => {
      'GROUPS_NO' => 1,
      'GROUPS_YES' => 1
    }
  },
  'VOID' => {
    'MOD_g' => {
      'GROUPS_NO' => undef,
      'GROUPS_YES' => undef
    },
    'MOD_' => {
      'GROUPS_YES' => undef,
      'GROUPS_NO' => undef
    }
  }
}


##</code><code>##

  DB<36> @res = ( $str =~ /(2.):(1.):(0.)/g )

  DB<37> x @res
0  21
1  11
2  01
3  22
4  12
5  02
6  23
7  13
8  03
  DB<38>