A Capture is an object representing arguments in a function call.
More generally,
Capture objects express annotated nodes with children such as capture groups returned by rules,
XML DOM nodes,
argument lists and more.

For example,
the arguments in say("Hello",
"World") is a Capture object denoted by \("Hello",
"World").

During multi-dispatch, a tie-breaking parameter may bind to the invocant argument (e.g. for multi-methods), or one of the positional arguments.

However, regardless of single- or multi- dispatch, the argument list (Capture) can never have more than one invocant. Typically, the presence of an invocant indicates a method-call (which may fall back to a subroutine-call); the lack of invocant means a subroutine-call.

Method/subroutine calls are determined by the presence of an invocant at the calling site. Single/multi dispatch are determined by the presence of "multi" in the declaration site. The two concepts are entirely orthogonal.

A Capture object may hold named arguments that occur twice or more. When it's bound to a variable in the Signature, if the sigil is @, then it expands to a list of all arguments (in the order they were specified).

Otherwise (i.e. if it's bound to a scalar or a slurpy hash), the last argument overrides the previous ones.

Unlike in Perl 5, this means that you can get back the Array object with:

my @y2 := $$x; # get back the invocant

instead of:

my @y2 := @$x; # WRONG: $x contains no positional parts

Manipulating the original value via the $x capture is still possible:

$$x.push("another element");

Note the need for the extra $ sigil, implying we are accessing the captured invocant. @$x.push() would mean an attempt to add an extra positional argument into $x; this would fail as all parts are immutable in an Capture object.

Perl 6 has a few other provisions for this (e.g., .wrap), but if you want more control over invocation, you can take advantage of the default Signature for methods, which puts all positionals in @_ and named arguments in %_:

method front_meth {
$!real_obj.back_meth( |<< @_, %_ );
}

You can also take the argument list as a Capture object, and merge it with another method invocation:

method front_meth (\$args) {
$!real_obj_A.back_meth( |$args );
}

This works because when there is already an invocant present, further invocants in the constructing argument list will be ignored.

Yes. The right-hand side in both case is a single List object constructed with the list-associative infix:<,> operator, but it is flattened in the second case, and its elements are put into the previously allocated Array container bound to @y:

give_birth() gets called with 'x', 'y', and 'z' as positional arguments, and :animal<moose> as a named argument. give_birth() can return a Moose object - and $rv is assigned a Capture object with the Moose object in its invocant slot. $rv has the same positional and named slots as the Moose object - and you can retrieve the Moose back through $rv as Animal.

Nested captures in the rule then become nested Capture objects within positional slots in $/, which allows them to be retrieved as arguments for additional functions. And so you can bind annotated nodes of a tree to particular function calls, passing the data straight in thanks to the equivalence of Captures returned by rules and Captures used to invoke functions and methods. As such, Captures could be considered a natural data type for XML nodes, and provide considerable power for parsing DOMs using Rules, and providing native tree manipulations.