Documentation for routine append assembled from the following types:

class Any

From Any

(Any) method append

Defined as:

multi method append(Any:U \SELF: |values)

In the case the instance is not a positional-thing, it instantiates it as a new Array, otherwise clone the current instance. After that, it appends the values passed as arguments to the array obtained calling Array.append on it.

my $a;
say $a.append; # OUTPUT: «[]␤» 
my $b;
say $b.append((1,2,3)); # OUTPUT: «[1 2 3]␤»

language documentation Independent routines

From Independent routines

(Independent routines) sub append

Defined as:

multi sub append(\a, **@b is raw)
multi sub append(\a, \b)

Calls method append on the first argument, passing the remaining arguments. Method append is supposed to add the provided values to the end of the collection or parts thereof. Unlike method push, method append should follow the single argument rule. So if you want to implement a conforming method append for a new collection type, it should behave as if its signature was just:

multi method append(::?CLASS:D: +values --> ::?CLASS:D)

Similar to routine push, you may need to add a multi method if you want to support autovivification:

multi method append(::?CLASS:U: +values --> ::?CLASS:D)

The subroutine form of append can be helpful when appending to the values of a Hash. Whereas method append will silently ignore literal pairs that are interpreted as named arguments, the subroutine will throw:

my %h = i => 0;
append %h, i => (1, 42);
CATCH { default { put .message } };
# OUTPUT: «Unexpected named argument 'i' passed␤»

class Nil

From Nil

(Nil) method append

method append(*@)

Warns the user that they tried to append onto a Nil (or derived type object).

class Array

From Array

(Array) method append

Defined as

multi method append(Array:D: **@values is raw --> Array:D)
multi method append(Array:D: \arg --> Array:D)

Adds the provided values to the end of the array and returns the modified array, or throws if the invocant array or an argument that requires flattening is lazy.

In contrast with method push, method append adheres to the single argument rule and is probably best thought of as:

multi method append(Array:D: +values --> Array:D)

This means that if you pass a single argument that is a non-itemized Iterable, append will try to flatten it.

For example:

my @a = <a b c>;
my @b = <d e f>;
@a.append: @b;
say @a.elems;               # OUTPUT: «6␤» 
say @a;                     # OUTPUT: «[a b c d e f]␤»

class Hash

From Hash

(Hash) method append

Defined as:

method append(+@values)

Append the provided Pairs or even sized list to the Hash. If a key already exists, turn the existing value into an Array and push new value onto that Array. Please note that you can't mix even sized lists and lists of Pairs. Also, bare Pairs or colon pairs will be treated as named arguments to .append.

my %h = a => 1;
%h.append('b', 2, 'c', 3);
%h.append( %(d => 4) );
say %h;
# OUTPUT: «{a => 1, b => 2, c => 3, d => 4}␤» 
%h.append('a', 2);
# OUTPUT: «{{a => [1 2], b => 2, c => 3, d => 4}␤»

Note: Compared to push, append will slip in the given value, whereas push will add it as is:

my %hb = :a[42, ]; %hb.append: "a" => <a b c a>;
say %hb; # OUTPUT: «{a => [42 a b c a]}␤» 
 
my %ha = :a[42, ]; %ha.push: "a" => <a b c a>;
say %ha; # OUTPUT: «{a => [42 (a b c a)]}␤»

role Buf

From Buf

(Buf) method append

method append( $elems )

Appends at the end of the buffer

$bú.append( @φ[5..10] );
say $bú.raku; # OUTPUT: «Buf.new(1,1,2,3,5,8,13,21,34,55,89)»