You needn't use split(). A regex is sufficient:

my $str = "foo|{baz|qux}|fax";

my @parts = $str =~ /(
                        \{.+?\}  # e.g., {baz|qux}
                     |
                        [^|]+    # e.g., foo
                     )
                     (?:\||$)    # |, or end of string
                    /xg;
$" = "\n";
print "@parts";
__END__
foo
{baz|qux}
fax
[download]

Hah. Caught using a pair of pliers when I needed a hammer. Hats off to you, dws and belkajm.

Indeed, ++ to dws, this works perfectly, my thanks.

Starting from the premise that a lame but almost working answer is better than none:

/(             #A nice simple capture, for
  [^|\{]+      #a block of nonsignificant chars
 |
  \{ [^}]+ \}  #or a bracketed block
 ) 
  \|           #followed by a pipe.
/x
[download]

Doesn't _quite_ work - produces the following on output:

$VAR1 = [
          '',
          'foo',
          '',
          '{baz|qux}',
          'fax'
        ];
[download]

This indicates my need for enlightenment - if I use (?:) instead of (), it returns just (' ',' ','fax'), not the captures... so maybe there's some deeper magic going on in split which I'm not clear on.

Update: Found why it's adding the captured elems, but not why using (?:) breaks it.

from split manpage:

If the PATTERN contains parentheses, additional list elements are crea
+ted 
from each matching substring in the delimiter.
[download]

Update again: Now I fool feelish. Okay, yup, like would make sense, split uses pre/postmatch stuff - the end result being that since (?:) is part of the match, it gets dropped, and since that's the content I'm looking for (the foo or {bar|baz} bit), I lose my content.

hm. now I'm as stumped as BUU. Can't use lookbehinds, cuz variable length lookbehinds aren't implemented... *falls into contemplative silence*.

But is that approximately what you're looking for?

if you modify this slightly, and use it in this form it seems to work:

$a = "foo|{baz|qux}|fax";
@b = ($a =~ /(
        [^|\{]+
       |
        \{ [^}]+ \}
        )
        (?: \| | $ )
      /xg);
[download]

@b now contains:

$VAR1 = [
          'foo',
          '{baz|qux}',
          'fax'
        ];
[download]

Note that this regexp can't cope with recursive brackets, and can therefore be fooled. Any example of this would be:
$a = "foo|{baz|{qu}x|fax";
which would result in:


$VAR1 = [
          'foo',
          'baz',
          'qu}x}',
          'fax'
        ];
[download]


I'm afraid that I haven't got round to getting the owl book yet, so i'm not really that hot with regexps yet. In fact, i'm coming back to perl now from a years absence. If someone could show how to modify the regexp to cope with things like this, I would be grateful.

Yoda