my @names;
while( $string=~s/\?<([a-z]+)>// ){push(@names,$1);}

print "Names: ",join(',',@names),"\n";
[download]

This is the confusion which results when someone does not use code tags. The OP actually did use [a-z]+, as can be seen when clicking on the xml link, but it rendered poorly.

my $string = 'yourregex here';
while($string =~ m/\(\?\<([a-zA-Z0-9]+)\>/g) {
    print $1, "\n";
}
[download]

Please post a few lines of (representative) sample data.

use 5.010;
"" =~ /(?:$str)?/;
while (my ($key, $matches) = each %-) {
    if (@$matches > 1) {
        say "Duplicate name $key";
    }
}
[download]

Sorry for nitpicking, but in praxis this only works with a string where all groups match, "" isn't enough.

use 5.010;
"" =~ /(?<mon>\w+)\s(?<mon>\w+)/;
print scalar keys %-;                  # 0
[download]

Now constructing such a string is in general even more difficult than just parsing for named captures labels.

Good idea anyway! :)

Cheers Rolf

Thank you for playing, but you fail.

"" =~ /(?:(?<mon>\w+)\s(?<mon>\w+))?/;

say scalar keys %-;   # 1
[download]

All that's required is for the pattern to match. Taking the pattern, and wrapping it inside a (?: )? will make it match against "" (except for some degenerate cases). If you look back at my code, this is exactly what I did.

This looks like a syslog message line. If you have access to the syslog daemon configuration and already use syslog-ng, you already have macros to split all the standard fields. Then you could pipe the payload message to your perl script. In there a split /[ =]+/ ... looks like it would yield the proper {name, value} pairs. I gather rsyslog has similar features.

Main advantage of this approach: your actions run in real-time, as the events come in.

Right now the regex is huge and complicated. Imagine trying to prove it captures everything you need, with no lost data, and it captures no more than you need, to maximze the data you can process in available memory. Or imagine you need to hire someone to make changes. You can hire a first year student at X kroner / hour, a second year student at X^2 k/h, a senior at X! k/h .... or even worse, imagine having to figure out next year, what you were had in mind when you programmed it.

If split partitions your problem into smaller, more easily understandable problems, that sounds like a good idea to me. Split is fast and efficient.

Alternately, define a number of small regex, and then assemble them into a larger structure. That way the components are named, so you have an idea what it is intended to achieve, and decipherment is bounded, with a limited number of characters to figure out. Compare to the regex-as-a-whole, where you can't tell where part one ends and part two begins.

> perl -e 'use re 'debug';/(?i-xsm:(?<mon>\w+)\s+(?<day>\d+)\s+)/' 
Compiling REx "(?i-xsm:(?<mon>\w+)\s+(?<day>\d+)\s+)"
Final program:
   1: OPEN1 'mon' (3)
   3:   PLUS (5)
   4:     ALNUM (0)
   5: CLOSE1 'mon' (7)
   7: PLUS (9)
   8:   SPACE (0)
   9: OPEN2 'day' (11)
  11:   PLUS (13)
  12:     DIGIT (0)
  13: CLOSE2 'day' (15)
  15: PLUS (17)
  16:   SPACE (0)
  17: END (0)
stclass ALNUM plus minlen 4 
Freeing REx: "(?i-xsm:(?<mon>\w+)\s+(?<day>\d+)\s+)"
[download]

Now fetching all /OPEN\d+ '(\w+)'/-opcodes shouldn't be too difficult.

See perldoc re for more options.

UPDATE: shrank example.

map { s/>.*// } (my @items = split /\?</, $pat) ;
[download]

my %freq = () ;
map { $freq{$_}++ } @items ;
[download]

I couldn't come up with a way to scan for duplicates all in one line, which is a little disappointing, but maybe there's something clever to do.