Hi,
Captures are sensitive things, they can only be used "as-is" inside a
scalar, otherwise you have to enforce a context and it is no longer a
capture, but one of the views of its content.
for instance...
sub foo {
...
return @thingy, :named($value);
}
sub bar($capture) {
my $named := |$capture;
my @things := |$capture;
...
}
bar(foo());
The problem with the above code, is that the :($capture) signature,
already enforces item context, and therefore the two statements in sub
bar will simply fail.
That being said, I'd like to suggest a new syntax:
sub bar(\$capture) {
...
}
This syntax will mean that you want that positional argument without
forcing any context. This is something different from
sub bar(|$capture) {
...
}
which takes the entire capture sent to that invocation and store in the
variable, the proposed syntax would allow:
sub foo {
return 1,2,3;
}
sub bar(\$capture, $other) {
...;
}
bar(foo(), "somethingelse");
This need came out because of
method postcircumfix:<( )>($capture)
we need to receive the positional argument for .() without forcing the
context. I understand this method used to have a (|$capture) signature,
and it was changed by a request I made, but I'd like to remember that (|
$capture) and (\$capture) are completely different things, and SMOP
already takes advantage on that, the current signature for .() in SMOP
is:
method postcircumfix:<( )>(\$capture, :$cc)
where $cc is there to support call with current contination (currently
used in exception handling).
The other method that requires such concept is
method dispatch($object, $identifier, \$capture) {...}
in ClassHOW, which will actually call postcircumfix:<( )> in the end, so
it needs the capture "as-is".
Aditionally to this syntax, one point requires attention. If
foo((a => 1));
makes the pair a positional argument, it's natural that
foo((|$capture));
makes the capture a positional argument, instead of expanding it into
the argument list, and thus closing the loop in "how to use a capture
object" ;)
daniel
