You're right. I prefer this approach as it lets perl do the job of building and keeping track of the list internally - that's what "more merit" was referring to. The original version of this approach did not have the grep, and I didn't think about the fact I was introducing a second loop when I added it.

I tried to get rid of it as follows:

#!/usr/bin/perl -wl
use strict;

sub msplit {
    my ($delim, $str) = @_;
    my $pat;
### $pat = q/ (?> (.*?) (??{ shift @$delim }) (??{ $pat }) )? /; ### U
+PDATE: WRONG
    $pat = q/ (?> (.*?) $$delim[0] (??{ shift @$delim; $pat }) )? /;
    $str =~ /^ $pat (.+) /x;
}

print for map "'$_'", msplit [qw(: :: \s+)], "a:b::c  d";
[download]

I like this version even better as it should be even more economical: the first failed match bails out of the pattern so it does not do any more work on building the regex than necessary.

Unfortunately Perl complains about the lack of use re 'eval'; even if I add it. I'm not quite sure as to what's missing.. Maybe one of our resident regex spell casters can enlighten me?

Makeshifts last the longest.

I admit it, I can't see how this would work? Wouldn't you at least need /g to make this produce more than one capture?

(Said, with the distinct feeling that I'm missing something very obvious or very clever:)

---

Okay you lot, get your wings on the left, halos on the right. It's one size fits all, and "No!", you can't have a different color.
Pick up your cloud down the end and "Yes" if you get allocated a grey one they are a bit damp under foot, but someone has to get them.
Get used to the wings fast cos its an 8 hour day...unless the Govenor calls for a cyclone or hurricane, in which case 16 hour shifts are mandatory.
Just be grateful that you arrived just as the tornado season finished. Them buggers are real work.

:) See perlre:

(??{ code })

WARNING: This extended regular expression feature is considered highly experimental, and may be changed or deleted without notice. A simplified version of the syntax may be introduced for commonly used idioms.

This is a "postponed" regular subexpression. The code is evaluated at run time, at the moment this subexpression may match. The result of evaluation is considered as a regular expression and matched as if it were inserted instead of this construct.

The code is not interpolated. As before, the rules to determine where the code ends are currently somewhat convoluted.

The following pattern matches a parenthesized group:

$re = qr{
    \(
        (?:
            (?> [^()]+ ) # Non-parens without backtracking
            |
            (??{ $re })  # Group with matching parens
        )*
    \)
}x;
[download]

I just noticed I made an assumption too many myself - code is updated.

Makeshifts last the longest.