states that there is a difference between taking a reference to a list, and a reference to an array:
Taking a reference to an enumerated list is not the same
as using square brackets--instead it's the same as
creating a list of references!
@list = (\$a, \@b, \%c);
@list = \($a, @b, %c); # same thing!
As a special case, \(@foo) returns a list of references to
the contents of @foo, not a reference to @foo itself.
Likewise for %foo, except that the key references are to
copies (since the keys are just strings rather than full-
So I have two questions:
- Why the distinction? Why are there two seperate behaviors?
- What is happening that creates the difference in behavior?
# example 1
my $ref1 = \(qw(one two three)); # should be called in list context
# example 2
my @list = qw(one two three);
my $ref2 = \@list;
# example 3
# returns same as example 1
my $ref3 = \(@list); # should be called in list context
print ref $ref1, "\n";
print ref $ref2, "\n";
print ref $ref3, "\n";
Based on these examples, my best guess is that the parentheses are the key. Going back to the "if it looks like a function, then it is a function" philosophy behind the interpreter, I guess \()
does look like a function. As such, \("one","two","three")
gets executed like a function call with n
arguments (3 in the case of the list). @list
gets flattened like any other list passed as an argument and so the behavior is basically the same for both cases.
That's my best guess anyway...
This @ISA my cool %SIG