What if the thing in the brackets is a function call? Normally the context drives whether the function "wants" to return a list or scalar. Instead, it seems that what the function does return matters? But then context is propagating in the wrong direction at runtime.

Also, is this a case where it really does treat a @name variable different from a scalar variable that holds a (ref to) a list? That could be an answer to a previous question, for real differences.

Can you give an example of your update, too? My reading teaches me that parens are only used for grouping, not to trigger context. (OTOH returning pairs seems to violate this principle too)

—John

I don't know :) but you can force context for function calls to be anything you want

Yes, the context of the function call can be whatever you want.

$x = @array[+foo];
[download]

The call to foo is made in numeric item context. The result, a number, is then "evaluated" in list context and passed to postcurcumfix:< > as the first item in the list, which it can perceive in various ways depending on the parameter list declaration. But it knows that a single number was passed and acts accordingly.

Suppose that the value in the array at that position is 42. Will the return value contain a scalar, 42, or a list of one item? The function execution does not get to impose the context of its surrounding expression; that is decided at compile time. Since the argument is not known to be singular at compile-time (using rules yet to be explained), it must be in list context. So:

$temp= foo;
$x= @array[$temp];  # holds Num of 42

$x= @array[foo];  # holds Array ref of [ 42 ]
[download]

I suppose that the presence of a context specifier "+" as the top-level expression in the brackets could be among the rules the compiler uses to decide this is the singular form. But this is NOT explained anywhere, and that is my point.

—John
Seriously jet-lagged