Close, but no cigar. You were assigning an array (the @_) to a scalar, which translates to the number of elements in the array.

You want:
$hash{$1} = [split /,/, $2];

Which creates the anonymous arrayref you were mentioning, which lives quite happily as a scalar

So does my inital reponse not accomplish the same thing in another way? I didn't test it, but if memory serves, its effect is identical.

Hot Pastrami

It's not identical if there's already something in the hash element. It reuses any existing hashref pointer, and may even fail if there's an arrayref or something else there instead.

That's why I prefer avoiding the @{$foo[bar]} = ... forms, opting instead for the $foo[bar] = [...] forms as being much safer.

-- Randal L. Schwartz, Perl hacker

It does indeed accomplish the same thing, but it obfuscates what you're doing. (You dereference your lvalue, while I make a references of the rvalue). As proof, I wasn't sure your way worked until I tested it. :)

To each his own.

To do what split wants and to do what you want, perl has to assign the list results of the split operation to @_, then evaluate @_ in scalar context, giving you the number of elements. You might as well just use m// with your pattern in scalar context.

Your second one works because you do as swiftone recommends, creating an anonymous array out of the split results. That puts split in list context. Next, you dereference the anonymous array, and evaluate that in scalar context. Same results, except that wrapping the split in the reference/dereference stuff fools perl just enough that it doesn't give you the error message.

As for the error message, it means "Try not to do a potentially expensive operation if you're just going to throw away the results."

thank you much,

As a question though, would there be a time when it would make sense to use split in scalar context (and thus avoid the @_?). Not as if i'm qualified to ask question's on perl's behavior, but if this is deprecated (as diagnostics says) is it going to be replaced by some other behavior?

jynx

UPDATE: please disregard this, i apparently wasn't fully reading the above post (but thanx again swiftone for pointing that out)

1) I can't think of a time you'd use split in a scalar context. See chromatic's post about m//;

2) The features of splitting to @_ was there to reduce temporary variables. It's deprecated because it encourages trampling on subroutine arguments.

First, it should be noted that there is no such thing as array context in Perl. The only contexts are scalar, list, and void (which is a special kind of scalar context). Scalar has several subcontexts, including string, numeric, and boolean. (It's generally accepted that wantarray was misnamed, and should have been wantlist instead.)

split is almost always used in a list context, where it returns a list of substrings split out from the target string. However, when split is used in a scalar context, as in   $count = split ' ', $string split instead returns the size of the list of substrings. At the same time, the list of substrings is placed in the array @_. In other words, the behavior is effectively   @_ = split ' ', $string; $count = @_;

This implicit assignment to @_ by split in scalar context is deprecated, which is why you receive a warning. You can avoid the warning by using a temporary array.   $count = @tmp = split ' ', $string

However, you don't want the count of elements; you want a reference to an array, which you must ask for explicitly.   $ref = [ split ' ', $string ] The anonymous array constructor puts split in list context (remember, there is no such thing as array context) and returns a reference to an array of substrings.

/(\S+)\s?=?\s?\[(.+)\]$/  && do {
   @{$hash{$1}} = split /,/, $2;
   next;
};
[download]

my $string = "This is a @{[ &test() ]}";
[download]