Rules / Types, classes & roles / composite

List Reference

Sequence of values

What it is #

Position in the hierarchy #

Inherits from—
Does—
Inherited byArray, Slip

Routines #

Signatures are reproduced from the documentation, including their declared return types. A routine listed here is part of the type's published interface; whether Raku++ implements it is a separate question, answered by the examples below.

method ACCEPTS #

multi method ACCEPTS(List:D: $topic)

If $topic is an Iterable, returns True or False based on whether the contents of the two Iterables match. A Whatever element in the invocant matches anything in the corresponding position of the $topic Iterable. A HyperWhatever matches any number of any elements, including no elements:

routine list #

multi        list(+list)
multi method list(List:D:)

The method just returns the invocant self. The subroutine adheres to the single argument rule: if called with a single argument that is a non-itemized Iterable it returns a List based on the argument's iterator; otherwise it just returns the argument list. For example: The last statement uses the prefix:<

routine elems #

sub    elems($list --> Int:D)
method elems(List:D: --> Int:D)

Returns Int:D.

Returns the number of elements in the list.

routine end #

sub    end($list --> Int:D)
method end(List:D: --> Int:D)

Returns Int:D.

Returns the index of the last element.

routine keys #

sub    keys($list --> Seq:D)
method keys(List:D: --> Seq:D)

Returns Seq:D.

Returns a sequence of indexes into the list (e.g., 0...(@list.elems-1)).

routine values #

sub    values($list --> Seq:D)
method values(List:D: --> Seq:D)

Returns Seq:D.

Returns a sequence of the list elements, in order.

routine kv #

sub    kv($list --> Seq:D)
method kv(List:D: --> Seq:D)

Returns Seq:D.

Returns an interleaved sequence of indexes and values. For example

routine pairs #

sub    pairs($list --> Seq:D)
method pairs(List:D: --> Seq:D)

Returns Seq:D.

Returns a sequence of pairs, with the indexes as keys and the list values as values.

routine antipairs #

method antipairs(List:D: --> Seq:D)

Returns Seq:D.

Returns a Seq of pairs, with the values as keys and the indexes as values, i.e. the direct opposite to pairs.

routine invert #

method invert(List:D: --> Seq:D)

Returns Seq:D.

Assumes every element of the List is a Pair. Returns all elements as a Seq of Pairs where the keys and values have been exchanged. If the value of a Pair is an Iterable, then it will expand the values of that Iterable into separate pairs.

routine join #

sub    join($separator, *@list)
method join(List:D: $separator = "")

Treats the elements of the list as strings by calling .Str on each of them, interleaves them with $separator and concatenates everything into a single string. Example: The method form also allows you to omit the separator: Note that the method form does not flatten sublists: The subroutine form behaves slurpily, flattening all arguments after the first into a single list:

routine map #

multi method map(\SELF: &block)
multi        map(&code, +values)

Examples applied to lists are included here for the purpose of illustration. For a list, it invokes &code for each element and gathers the return values in a sequence and returns it. This happens lazily, i.e. &code is only invoked when the return values are accessed.Examples: map inspects the arity of the code object, and tries to pass as many arguments to it as expected: iterates the list two items at a time.

method flatmap #

method flatmap(List:D: &code --> Seq:D)

Returns Seq:D.

Convenience method, analogous to .map(&block).flat.

method gist #

multi method gist(List:D: --> Str:D)

Returns Str:D.

Returns the string containing the parenthesized "gist" of the List, listing up to the first 100 elements, separated by space, appending an ellipsis if the List has more than 100 elements. If List is-lazy, returns string '(...)'

routine grep #

sub    grep(Mu $matcher, *@elems, :$k, :$kv, :$p, :$v --> Seq:D)
method grep(List:D:  Mu $matcher, :$k, :$kv, :$p, :$v --> Seq:D)

Returns Seq:D.

Returns a sequence of elements against which $matcher smartmatches. The elements are returned in the order in which they appear in the original list. Examples: Note that if you want to grep for elements that do not match, you can use a none-Junction: Another option to grep for elements that do not match a regex is to use a block: The reason the example above works is because a regex in Boolean context applies

routine first #

sub    first(Mu $matcher, *@elems, :$k, :$kv, :$p, :$end)
method first(List:D:  Mu $matcher?, :$k, :$kv, :$p, :$end)

Returns the first item of the list which smartmatches against $matcher, returns Nil when no values match. The optional named parameter :end indicates that the search should be from the end of the list, rather than from the start. Examples: The optional named parameters :k, :kv, :p provide the same functionality as on slices: Return the index value of the matching element. Index is always counted from

method head #

multi method head(Any:D:) is raw
multi method head(Any:D: Callable:D $w)
multi method head(Any:D: $n)

This method is directly inherited from Any, and it returns the first $n items of the list, an empty list if $n <= 0, or the first element with no argument. The version that takes a Callable uses a WhateverCode to specify all elements, starting from the first, but the last ones. Examples:

method tail #

multi method tail(List:D:)
multi method tail(List:D: $n --> Seq:D)

Returns Seq:D.

Returns a Seq containing the last $n items of the list. Returns an empty Seq if $n <= 0. Defaults to the last element if no argument is specified. Throws an exception if the list is lazy. Examples: In the first case, $n is taking the shape of a WhateverCode to indicate the number of elements from the beginning that will be excluded. $n can be

routine categorize #

multi method categorize()
multi method categorize(Whatever)
multi method categorize($test, :$into!, :&as)
multi method categorize($test, :&as)
multi        categorize($test, +items, :$into!, *%named )
multi        categorize($test, +items, *%named )

These methods are directly inherited from Any; see Any.categorize for more examples. This routine transforms a list of values into a hash representing the categorizations of those values according to $test, which is called once for every element in the list; each hash key represents one possible categorization for one or more of the incoming list values, and the corresponding hash value

routine classify #

multi method classify($test, :$into!, :&as)
multi method classify($test, :&as)
multi        classify($test, +items, :$into!, *%named )
multi        classify($test, +items, *%named )

Transforms a list of values into a hash representing the classification of those values; each hash key represents the classification for one or more of the incoming list values, and the corresponding hash value contains an array of those list values classified into the category of the associated key. $test will be an expression that will produce the hash keys according to which the elements are going to be classified.

method Bool #

method Bool(List:D: --> Bool:D)

Returns Bool:D.

Returns True if the list has at least one element, and False for the empty list.

method Str #

method Str(List:D: --> Str:D)

Returns Str:D.

Stringifies the elements of the list and joins them with spaces (same as .join(' ')).

method Int #

method Int(List:D: --> Int:D)

Returns Int:D.

Returns the number of elements in the list (same as .elems).

method Numeric #

method Numeric(List:D: --> Int:D)

Returns Int:D.

Returns the number of elements in the list (same as .elems).

method Capture #

method Capture(List:D: --> Capture:D)

Returns Capture:D.

Returns a Capture where each Pair, if any, in the <List has been converted to a named argument (with the key of the Pair stringified). All other elements in the List are converted to positional arguments in the order they are found, i.e. the first non pair item in the list becomes the first positional argument, which gets index 0, the second non pair item becomes the second

routine pick #

multi        pick($count, *@list --> Seq:D)
multi method pick(List:D: $count --> Seq:D)
multi method pick(List:D: --> Mu)
multi method pick(List:D: Callable $calculate --> Seq:D)

Returns Seq:D or Mu.

If $count is supplied: Returns $count elements chosen at random and without repetition from the invocant. If * is passed as $count, or $count is greater than or equal to the size of the list, then all elements from the invocant list are returned in a random sequence; i.e. they are returned shuffled. In method form, if $count is omitted: Returns a single random item from the list, or Nil if the list is empty

routine roll #

multi        roll($count, *@list --> Seq:D)
multi method roll(List:D: $count --> Seq:D)
multi method roll(List:D: --> Mu)

Returns Seq:D or Mu.

If $count is supplied: Returns a sequence of $count elements, each randomly selected from the list. Each random choice is made independently, like a separate die roll where each die face is a list element. If * is passed as $count returns a lazy, infinite sequence of randomly chosen elements from the original list. If $count is omitted: Returns a single random item from the list, or Nil if the list is empty

routine eager #

multi method eager(List:D: --> List:D)

Returns List:D.

Evaluates all elements in the List eagerly, and returns them as a List.

routine reverse #

multi        reverse(*@list  --> Seq:D)
multi method reverse(List:D: --> Seq:D)

Returns Seq:D.

Returns a Seq with the same elements in reverse order. Note that reverse always refers to reversing elements of a list; to reverse the characters in a string, use flip. Examples:

routine rotate #

multi        rotate(@list,  Int:D $n = 1 --> Seq:D)
multi method rotate(List:D: Int:D $n = 1 --> Seq:D)

Returns Seq:D.

Returns a Seq with the list elements rotated to the left when $n is positive or to the right otherwise. Examples: Note: Before Rakudo release 2020.06 a new List was returned instead of a Seq.

routine sort #

multi        sort(*@elems      --> Seq:D)
multi        sort(&custom-routine-to-use, *@elems --> Seq:D)
multi method sort(List:D:      --> Seq:D)
multi method sort(List:D: &custom-routine-to-use  --> Seq:D)

Returns Seq:D.

Sorts the list, smallest element first. By default infix:<cmp> is used for comparing list elements. If &custom-routine-to-use is provided, and it accepts two arguments, it is invoked for pairs of list elements, and should return Order::Less, Order::Same or Order::More. If &custom-routine-to-use accepts only one argument, the list elements are sorted according to C<<custom-routine-to-use($a) cmp

routine reduce #

multi method reduce(Any:D: &with)
multi        reduce (&with, +list)

Returns a single "combined" value from a list of arbitrarily many values, by iteratively applying a routine which knows how to combine two values. In addition to the subroutine and the list, an initial value can be provided to initialize the reduction, which ends up being the return value if the list is empty. Thus reduce f, init, list combines the elements of the list from left to right, as is shown in the following pseudocode:

routine produce #

multi        produce(&with, *@values)
multi method produce(List:D: &with)

Generates a list of all intermediate "combined" values along with the final result by iteratively applying a function which knows how to combine two values. If @values contains just a single element, a list containing that element is returned immediately. If it contains no elements, an exception is thrown, unless &with is an operator with a known identity value. If &with is the function object of an operator, its

routine combinations #

multi        combinations($from, $of = 0..*             --> Seq:D)
multi method combinations(List:D: Int() $of             --> Seq:D)
multi method combinations(List:D: Iterable:D $of = 0..* --> Seq:D)

Returns Seq:D.

Returns a Seq with all $of-combinations of the invocant list. $of can be a numeric Range, in which case combinations of the range of item numbers it represents will be returned (i.e. 2.6 .. 4 will return 2-, 3-, and 4-item combinations). Otherwise, $of is coerced to an Int. Above, there are three possible ways to combine the 2-items lists from the

routine permutations #

multi        permutations(Int()    $from --> Seq:D)
multi        permutations(Iterable $from --> Seq:D)
multi method permutations(List:D:        --> Seq:D)

Returns Seq:D.

Returns all possible permutations of a list as a Seq of lists: permutations treats all elements as unique, thus (1, 1, 2).permutations returns a list of 6 elements, even though there are only three distinct permutations, due to first two elements being the same. The subroutine form behaves the same as the method form, computing permutations from its first argument $from. If $from is not an

routine rotor #

method rotor(+@cycle, Bool() :$partial --> Seq:D)

Returns Seq:D.

Returns a sequence of lists, where each sublist is made up of elements of the invocant. In the simplest case, @cycle contains just one integer, in which case the invocant list is split into sublists with as many elements as the integer specifies. If :$partial is True, the final chunk is included even if it doesn't satisfy the length requirement: If the element of @cycle is a Pair instead, the key of the

method batch #

multi method batch(Int:D $batch --> Seq)
multi method batch(Int:D :$elems --> Seq)

Returns Seq.

Returns a sequence of lists, wherein each list with the exception of the last one is guaranteed to comprise a number of elements equal to the batch size specified by $batch or $elems, respectively. If the invocant has a number of elements that is not an integer multiple of the batch size, the last list in the returned sequence will contain any remaining elements and thus have fewer than $batch or $elems elements. Accordingly, .batch($batch) is

routine cross #

sub cross(+@e, :&with --> Seq:D)

Returns Seq:D.

Computes the cross-product of two or more lists or Iterables. This returns a sequence of lists where the first item in each list is an item from the first iterable, the second is from the second given iterable, etc. Every item will be paired with every other item in all the other lists. The cross routine has an infix synonym as well, named X.

routine zip #

sub zip(+@e, :&with --> Seq:D)

Returns Seq:D.

Builds a 'list of lists', returned as a sequence, from multiple input lists or other Iterables. zip iterates through each of the input lists synchronously, 'Zipping' them together, so that elements are grouped according to their input list index, in the order that the lists are provided. zip has an infix synonym, the Z operator. zip can provide input to a for loop :

routine roundrobin #

sub roundrobin(+list-of-lists --> Seq)

Returns Seq.

Builds a 'list of lists', returned as a sequence, from multiple input lists or other Iterables. roundrobin returns an identical result to that of zip, except when the input lists are allowed to have an unequal number of elements. roundrobin does not terminate once one or more of the input lists become exhausted, but proceeds until all elements from all lists have been processed.

routine sum #

sub    sum($list  )
method sum(List:D:)

Returns the sum of all elements in the list or 0 if the list is empty. Throws an exception if an element can not be coerced into Numeric. If the list includes a Junction, the result will accordingly be a Junction: When called on native integer arrays, it is also possible to specify a :wrap named parameter. This will add the values as native integers, wrapping around if they exceed the size of a native integer. If you are

method fmt #

method fmt($format = '%s', $separator = ' ' --> Str:D)

Returns Str:D.

Returns a string where each element in the list has been formatted according to $format and where each element is separated by $separator. If the list contains nested sub-lists, then fmt will flatten them before formatting each element. Thus, fmt will treat [1, 2, [3, 4]] as a list with 4 elements rather than 3. For more information about formats strings, see sprintf.

method from #

Assumes the list contains Match objects and returns the value of .from called on the first element of the list.

method to #

Assumes the List contains Matches, such as the $/ variable being a List, when using :g modifier in regexes. Returns the value of .to called on the last element of the list.

method sink #

method sink(--> Nil) { }

Returns Nil.

It does nothing, and returns Nil, as the definition clearly shows.

method Set #

In general, creates a set which has as members elements of the list. However, there might be some unexpected changes in case the list includes non-scalar data structures. For instance, with Pairs: The set will be composed of the keys of the Pair whose corresponding value is not 0, eliminating all the values. Please check the Set documentation for more examples and a

infix C<cmp> #

multi infix:<cmp>(List @a, List @b)

Evaluates Lists by comparing element @a[$i] with @b[$i] (for some Int $i, beginning at 0) and returning Order::Less, Order::Same, or Order::More depending on if and how the values differ. If the operation evaluates to Order::Same, @a[$i + 1] is compared with @b[$i + 1]. This is repeated until one is greater than the other or all elements are exhausted. If the Lists are of different lengths, at most only $n comparisons will be

Examples, run three ways #

Every example below comes from the official documentation, together with the output that documentation asserts. Each was then executed by Rakudo and by Raku++ when this page was built. Where the three agree, one result is shown; where they do not, all three are — because which of them is wrong is exactly the information worth having.

6 all-differ · 2 doc-drift · 44 no-output · 8 not-runnable · 81 ok · 1 rakudo-differs · 2 rakupp-differs

my class List does Iterable does Positional { }

Not executed: the documentation states no expected output for this example.

(1, 2, 3).shift;      # Error Cannot call 'shift' on an immutable 'List'
(1, 2, 3).unshift(0); # Error Cannot call 'unshift' on an immutable 'List'
(1, 2, 3).push(4);    # Error Cannot call 'push' on an immutable 'List'
(1, 2, 3).pop;        # Error Cannot call 'pop' on an immutable 'List'
(1, 2, 3)[0]:delete;  # Error Cannot remove elements from a List
(1, 2, 3)[0] := 0;    # Error Cannot use bind operator with this left-hand side
(1, 2, 3)[0] = 0;     # Error Cannot modify an immutable Int

Not executed: the documentation states no expected output for this example.

my $a = 'z';
my $list = ($a, $, 'b');

say $list[0].VAR.^name; # OUTPUT: «Scalar␤», containerized
say $list[1].VAR.^name; # OUTPUT: «Scalar␤», containerized
say $list[2].VAR.^name; # OUTPUT: «Str␤», non-containerized

$list[0] = 'a'; # OK!
$list[1] = 'c'; # OK!
$list[2] = 'd'; # Error: Cannot modify an immutable List

Neither engine can run this in isolation — the example depends on context from the surrounding text.

my $s = (1, 2, 3);
for $s { }      # one iteration
for $s.list { } # three iterations

Not executed: the documentation states no expected output for this example.

my $t = [1, 2, 3];
for $t { }      # one iteration
for $t.list { } # three iterations

Not executed: the documentation states no expected output for this example.

my @a = 1, 2, 3;
for @a { }      # three iterations
for @a.item { } # one iteration

Not executed: the documentation states no expected output for this example.

my $a = (1, 2, 3);
my $nested = ($a, $a);  # two elements

Not executed: the documentation states no expected output for this example.

my $flat = $nested.map({ .Slip });  # six elements, with explicit Slip

Not executed: the documentation states no expected output for this example.

my @b = <a b>;
@b.append: $a.list;     # The array variable @b has 5 elements, because
                        # the list $a is the sole argument to append

Not executed: the documentation states no expected output for this example.

say @b.elems;           # OUTPUT: «5␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

my @c = <a b>;
@c.append: $a.list, 7;  # The array variable @c has 4 elements, because
                        # the list $a wasn't the only argument and thus
                        # wasn't flattened by the append operation

Not executed: the documentation states no expected output for this example.

say @c.elems;           # OUTPUT: «4␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

my @d = <a b>;
@d.append: $a;          # The array variable @d has 3 elements, because
                        # $a is in an item context and as far as append is
                        # concerned a single element

Not executed: the documentation states no expected output for this example.

say @d.elems;           # OUTPUT: «3␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

my %h = a => 1, b => 2;
my @b = %h;   say @b.elems;     # OUTPUT: «2␤»
my @c = %h, ; say @c.elems;     # OUTPUT: «1␤»
my @d = $%h;  say @d.elems;     # OUTPUT: «1␤»
Output
2
1
1

Documentation, Rakudo and Raku++ all agree.

sub fe(*@flat) { @flat.elems }
say fe(<a b>, <d e>);           # OUTPUT: «4␤»
say fe(<a b>, <d e>.item);      # OUTPUT: «3␤»
Output
4
3

Documentation, Rakudo and Raku++ all agree.

my @a;
for @a, @a.list, @a.Seq -> \listoid {
    say listoid ~~ ()
}
# OUTPUT: «True␤True␤True␤»
Output
True
True
True

Documentation, Rakudo and Raku++ all agree.

say ()[33.rand]; # OUTPUT: «Nil␤»
Output
Nil

Documentation, Rakudo and Raku++ all agree.

my @a;
say [@a.elems, @a.Bool, ?@a]; # OUTPUT: «[0 False False]␤»
@a.push: 42;
say [@a.elems, @a.Bool, ?@a]; # OUTPUT: «[1 True True]␤»
say 'empty' unless @a;        # no output
Output
[0 False False]
[1 True True]

Documentation, Rakudo and Raku++ all agree.

say (1, 2, 3)       ~~ (1,  *, 3);  # OUTPUT: «True␤»
say (1, 2, 3)       ~~ (9,  *, 5);  # OUTPUT: «False␤»
say (1, 2, 3)       ~~ (   **, 3);  # OUTPUT: «True␤»
say (1, 2, 3)       ~~ (   **, 5);  # OUTPUT: «False␤»
say (1, 3)          ~~ (1, **, 3); # OUTPUT: «True␤»
say (1, 2, 4, 5, 3) ~~ (1, **, 3); # OUTPUT: «True␤»
say (1, 2, 4, 5, 6) ~~ (1, **, 5); # OUTPUT: «False␤»
say (1, 2, 4, 5, 6) ~~ (   **   ); # OUTPUT: «True␤»
say ()              ~~ (   **   ); # OUTPUT: «True␤»
Output
True
False
True
False
True
True
False
True
True

Documentation, Rakudo and Raku++ all agree.

my $tuple = (1, 2);         # an itemized List
put $tuple.list.raku;       # OUTPUT: «(1, 2)␤»
put list($tuple).raku;      # OUTPUT: «($(1, 2),)␤»
put list(|$tuple).raku;     # OUTPUT: «(1, 2)␤»
Output
(1, 2)
($(1, 2),)
(1, 2)

Documentation, Rakudo and Raku++ all agree.

put list(1, 2).raku;        # OUTPUT: «(1, 2)␤»
Output
(1, 2)

Documentation, Rakudo and Raku++ all agree.

put list($tuple<>).raku;    # OUTPUT: «(1, 2)␤»
put list(@$tuple).raku;     # OUTPUT: «(1, 2)␤»
Documentation
(1, 2)
(1, 2)
Rakudo
Raku++
(Any,)
()

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

put List.list.raku;         # OUTPUT: «(List,)␤»
Output
(List,)

Documentation, Rakudo and Raku++ all agree.

my class LinkedList {
has $.value;            # the value stored in this node
has LinkedList $.next;  # undefined if there is no next node

method values( --> Seq:D) {
    my $node := self;
    gather while $node {
        take $node.value;
        $node := $node.next;
    }
}

method list( --> List:D) {
    self.values.list;
}
}

my LinkedList $nodes;       # an empty linked list
put $nodes.list.raku;       # OUTPUT: «()␤»
Output
()

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4).elems; # OUTPUT: «4␤»
Output
4

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4).end; # OUTPUT: «3␤»
Output
3

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4).keys; # OUTPUT: «(0 1 2 3)␤»
Output
(0 1 2 3)

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4).^name;        # OUTPUT: «List␤»
say (1,2,3,4).values.^name; # OUTPUT: «Seq␤»
Output
List
Seq

Documentation, Rakudo and Raku++ all agree.

say <a b c>.kv; # OUTPUT: «(0 a 1 b 2 c)␤»
Output
(0 a 1 b 2 c)

Documentation, Rakudo and Raku++ all agree.

say <a b c>.pairs;   # OUTPUT: «(0 => a 1 => b 2 => c)␤»
Output
(0 => a 1 => b 2 => c)

Documentation, Rakudo and Raku++ all agree.

say <a b c>.antipairs;  # OUTPUT: «(a => 0 b => 1 c => 2)␤»
Output
(a => 0 b => 1 c => 2)

Documentation, Rakudo and Raku++ all agree.

my $l = List.new('a' => (2, 3), 'b' => 17);
say $l.invert;   # OUTPUT: «(2 => a 3 => a 17 => b)␤»
Output
(2 => a 3 => a 17 => b)

Documentation, Rakudo and Raku++ all agree.

say join ', ', <a b c>;             # OUTPUT: «a, b, c␤»
Output
a, b, c

Documentation, Rakudo and Raku++ all agree.

say <a b c>.join;               # OUTPUT: «abc␤»
Output
abc

Documentation, Rakudo and Raku++ all agree.

say (1, <a b c>).join('|');     # OUTPUT: «1|a b c␤»
Output
1|a b c

Documentation, Rakudo and Raku++ all agree.

say join '|', 1, <a b c>;       # OUTPUT: «1|a|b|c␤»
Output
1|a|b|c

Documentation, Rakudo and Raku++ all agree.

say ("a"|"b","c","d").join;     # OUTPUT: «any(acd,bcd)␤»
Documentation
any(acd,bcd)
Rakudo
any(acd, bcd)
Raku++
anycd

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

say ('hello', 1, 22/7, 42, 'world').map: { .^name } # OUTPUT: «(Str Int Rat Int Str)␤»
say map *.Str.chars, 'hello', 1, 22/7, 42, 'world'; # OUTPUT: «(5 1 8 2 5)␤»
Output
(Str Int Rat Int Str)
(5 1 8 2 5)

Documentation, Rakudo and Raku++ all agree.

sub b($a, $b) { "$a before $b" };
say <a b x y>.map(&b).join(', ');   # OUTPUT: «a before b, x before y␤»
Output
a before b, x before y

Documentation, Rakudo and Raku++ all agree.

((1, 2), <a b>).map({ .join(',')})

Not executed: the documentation states no expected output for this example.

sub s {
    my &loop-block = {
        return # return from sub s
    };
    say 'hi';
    (1..3).map: &loop-block;
    say 'oi‽' # dead code
};
s
# OUTPUT: «hi␤»
Output
hi

Documentation, Rakudo and Raku++ all agree.

put (1, 2, 3).gist;   # OUTPUT: «(1 2 3)␤»
put (1..∞).List.gist; # OUTPUT: «(...)␤»

put (1..200).List.gist;
# OUTPUT:
# (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
# 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
# 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
# 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
# 96 97 98 99 100 ...)
Documentation
(1 2 3)
(...)
Rakudo
(1 2 3)
(...)
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 ...)
Raku++
(1 2 3)
()
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200)

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

say ('hello', 1, 22/7, 42, 'world').grep: Int;              # OUTPUT: «(1 42)␤»
say grep { .Str.chars > 3 }, 'hello', 1, 22/7, 42, 'world'; # OUTPUT: «(hello 3.142857 world)␤»
Output
(1 42)
(hello 3.142857 world)

Documentation, Rakudo and Raku++ all agree.

say <a b 6 d 8 0>.grep(none Int);           # OUTPUT: «(a b d)␤»
say <a b c d e f>.grep(none /<[aeiou]>/);   # OUTPUT: «(b c d f)␤»
Output
(a b d)
(b c d f)

Documentation, Rakudo and Raku++ all agree.

say <a b c d e f>.grep({! /<[aeiou]>/})     # OUTPUT: «(b c d f)␤»
Output
(b c d f)

Documentation, Rakudo and Raku++ all agree.

say ('hello', 1, 22/7, 42, 'world').grep: Int, :k;
# OUTPUT: «(1 3)␤»
say grep { .Str.chars > 3 }, :kv, 'hello', 1, 22/7, 42, 'world';
# OUTPUT: «(0 hello 2 3.142857 4 world)␤»
say grep { .Str.chars > 3 }, :p, 'hello', 1, 22/7, 42, 'world';
# OUTPUT: «(0 => hello 2 => 3.142857 4 => world)␤»
Output
(1 3)
(0 hello 2 3.142857 4 world)
(0 => hello 2 => 3.142857 4 => world)

Documentation, Rakudo and Raku++ all agree.

say (1, 22/7, 42, 300).first: * > 5;                  # OUTPUT: «42␤»
say (1, 22/7, 42, 300).first: * > 5, :end;            # OUTPUT: «300␤»
say ('hello', 1, 22/7, 42, 'world').first: Complex;   # OUTPUT: «Nil␤»
Output
42
300
Nil

Documentation, Rakudo and Raku++ all agree.

say (1, 22/7, 42, 300).first: * > 5, :k;        # OUTPUT: «2␤»
say (1, 22/7, 42, 300).first: * > 5, :p;        # OUTPUT: «2 => 42␤»
say (1, 22/7, 42, 300).first: * > 5, :kv, :end; # OUTPUT: «(3 300)␤»
Output
2
2 => 42
(3 300)

Documentation, Rakudo and Raku++ all agree.

say <a b c d e>.head ;     # OUTPUT: «a␤»
say <a b c d e>.head(2);   # OUTPUT: «(a b)␤»
say <a b c d e>.head(*-3); # OUTPUT: «(a b)␤»
Output
a
(a b)
(a b)

Documentation, Rakudo and Raku++ all agree.

say <a b c d e>.tail(*-3);# OUTPUT: «(d e)␤»
say <a b c d e>.tail(2);  # OUTPUT: «(d e)␤»
say <a b c d e>.tail;     # OUTPUT: «e␤»
Output
(d e)
(d e)
e

Documentation, Rakudo and Raku++ all agree.

say <a b c d e>.tail( { $_ - 2 } ); # OUTPUT: «(c d e)␤»
Output
(c d e)

Documentation, Rakudo and Raku++ all agree.

sub mapper(Int $i) returns List {
    $i %% 2 ?? 'even' !! 'odd',
    $i.is-prime ?? 'prime' !! 'not prime'
}
say categorize &mapper, (1, 7, 6, 3, 2);
# OUTPUT: «{even => [6 2], not prime => [1 6], odd => [1 7 3], prime => [7 3 2]}␤»
Output
{even => [6 2], not prime => [1 6], odd => [1 7 3], prime => [7 3 2]}

Documentation, Rakudo and Raku++ all agree.

say classify { $_ %% 2 ?? 'even' !! 'odd' }, (1, 7, 6, 3, 2);
# OUTPUT: «{even => [6 2], odd => [1 7 3]}␤»
say ('hello', 1, 22/7, 42, 'world').classify: { .Str.chars };
# OUTPUT: «{1 => [1], 2 => [42], 5 => [hello world], 8 => [3.142857]}␤»
Output
{even => [6 2], odd => [1 7 3]}
{1 => [1], 2 => [42], 5 => [hello world], 8 => [3.142857]}

Documentation, Rakudo and Raku++ all agree.

say <Innie Minnie Moe>.classify( { $_.chars }, :as{ lc $_ });
# OUTPUT: «{3 => [moe], 5 => [innie], 6 => [minnie]}␤»
Output
{3 => [moe], 5 => [innie], 6 => [minnie]}

Documentation, Rakudo and Raku++ all agree.

<Innie Minnie Moe>.classify( { $_.chars }, :as{ lc $_ }, :into( my %words{Int} ) );
say %words; # OUTPUT: «{3 => [moe], 5 => [innie], 6 => [minnie]}␤»
Output
{3 => [moe], 5 => [innie], 6 => [minnie]}

Documentation, Rakudo and Raku++ all agree.

say ().Bool;  # OUTPUT: «False␤»
say (1).Bool; # OUTPUT: «True␤»
Output
False
True

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4,5).Str; # OUTPUT: «1 2 3 4 5␤»
Output
1 2 3 4 5

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4,5).Int; # OUTPUT: «5␤»
Output
5

Documentation, Rakudo and Raku++ all agree.

say (1,2,3,4,5).Numeric; # OUTPUT: «5␤»
Output
5

Documentation, Rakudo and Raku++ all agree.

my $list = (7, 5, a => 2, b => 17);
my $capture = $list.Capture;
say $capture.keys;                                # OUTPUT: «(0 1 a b)␤»
my-sub(|$capture);                                # OUTPUT: «7, 5, 2, 17␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

sub my-sub($first, $second, :$a, :$b) {
    say "$first, $second, $a, $b"
}

Not executed: the documentation states no expected output for this example.

my $list = (7, 5, a => 2, b => 17);
say so $list.Capture ~~ :($ where * == 7,$,:$a,:$b); # OUTPUT: «True␤»
Output
True

Documentation, Rakudo and Raku++ all agree.

$list = (8, 5, a => 2, b => 17);
say so $list.Capture ~~ :($ where * == 7,$,:$a,:$b); # OUTPUT: «False␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

say <a b c d e>.pick;           # OUTPUT: «b␤»
say <a b c d e>.pick: 3;        # OUTPUT: «(c a e)␤»
say <a b c d e>.pick: *;        # OUTPUT: «(e d a b c)␤»
Documentation
b
(c a e)
(e d a b c)
Rakudo
c
(c e a)
(c d a e b)
Raku++
a
(a c b)
(b a e d c)

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

say <a b c>.pick(**).head(10);  # OUTPUT: «((a c b c a b b c a b))␤»
Documentation
((a c b c a b b c a b))
Rakudo
(b a c b c a c a b b)
Raku++
(b a c)

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

say <a b c d e>.roll;       # 1 random letter
say <a b c d e>.roll: 3;    # 3 random letters
say roll 8, <a b c d e>;    # 8 random letters

Not executed: the documentation states no expected output for this example.

my $random-digits := (^10).roll(*);
say $random-digits[^15];    # 15 random digits

Not executed: the documentation states no expected output for this example.

my  \ll = (lazy 1..5).cache;

Not executed: the documentation states no expected output for this example.

say ll[];     # OUTPUT: «(...)␤»
say ll.eager  # OUTPUT: «(1 2 3 4 5)␤»
Documentation
(...)
(1 2 3 4 5)
Rakudo
Raku++
(ll)
((ll))

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

say <hello world!>.reverse;     # OUTPUT: «(world! hello)␤»
say reverse ^10;                # OUTPUT: «(9 8 7 6 5 4 3 2 1 0)␤»
Output
(world! hello)
(9 8 7 6 5 4 3 2 1 0)

Documentation, Rakudo and Raku++ all agree.

say <a b c d e>.rotate(2);   # OUTPUT: (c d e a b)
say <a b c d e>.rotate(-1);  # OUTPUT: (e a b c d)

Not executed: the documentation states no expected output for this example.

say (3, -4, 7, -1, 2, 0).sort;                  # OUTPUT: «(-4 -1 0 2 3 7)␤»
say (3, -4, 7, -1, 2, 0).sort: *.abs;           # OUTPUT: «(0 -1 2 3 -4 7)␤»
say (3, -4, 7, -1, 2, 0).sort: { $^b leg $^a }; # OUTPUT: «(7 3 2 0 -4 -1)␤»
Output
(-4 -1 0 2 3 7)
(0 -1 2 3 -4 7)
(7 3 2 0 -4 -1)

Documentation, Rakudo and Raku++ all agree.

my @resistance = (
    %( first-name => 'Kyle',  last-name => 'Reese'  ),
    %( first-name => 'Sarah', last-name => 'Connor' ),
    %( first-name => 'John',  last-name => 'Connor' ),
);
.say for @resistance.sort: { .<last-name>, .<first-name> };

Not executed: the documentation states no expected output for this example.

#`(
OUTPUT:
  {first-name => John, last-name => Connor}
  {first-name => Sarah, last-name => Connor}
  {first-name => Kyle, last-name => Reese}
)

Not executed: the documentation states no expected output for this example.

say <ddd aaa bbb bb ccc c>.sort( {.chars, .Str} );
# OUTPUT: «(c bb aaa bbb ccc ddd)␤»
Output
(c bb aaa bbb ccc ddd)

Documentation, Rakudo and Raku++ all agree.

say <01 11 111 2 20 02>.sort( { .Int, .comb.sum, .Str } );
# OUTPUT: «(01 02 2 11 20 111)␤»
Output
(01 02 2 11 20 111)

Documentation, Rakudo and Raku++ all agree.

sort;   # ERROR: «Must specify something to sort␤»

Not executed: the documentation states no expected output for this example.

say <a c b d e>.sort(:k); # OUTPUT: «(0 2 1 3 4)␤»
say sort <a c b d e>, :k; # OUTPUT: «(0 2 1 3 4)␤»
Output
(0 2 1 3 4)
(0 2 1 3 4)

Documentation, Rakudo and Raku++ all agree.

result0 = init
result1 = f(result0, list[0])
result2 = f(result1, list[1])
...
resultn = f(resultn-1, list[n-1])

Not executed: the documentation states no expected output for this example.

say reduce &infix:<+>, (1, 2, 3); # OUTPUT: «6␤»
say (1, 2, 3).reduce: &infix:<+>; # OUTPUT: «6␤»
say reduce &max, (5, 9, 12, 1);   # OUTPUT: «12␤»
Output
6
6
12

Documentation, Rakudo and Raku++ all agree.

say reduce &infix:<->, (10,);     # OUTPUT: «10␤»
Output
10

Documentation, Rakudo and Raku++ all agree.

my \strings = "One good string!", "And one another good string!";
say reduce { $^a ~ $^b }, '', |strings;               # like strings.join

Not executed: the documentation states no expected output for this example.

my \numbers = 1, 2, 3, 4, 5;
say reduce { $^a > $^b ?? $^a !! $^b }, 0, |numbers; # like numbers.max

Not executed: the documentation states no expected output for this example.

sub count-and-sum-evens( (Int \count, Int \sum), Int \x ) {
    x %% 2 ?? (count+1, sum+x) !! (count, sum)
}

Not executed: the documentation states no expected output for this example.

say reduce &count-and-sum-evens, (0, 0), |numbers;    # OUTPUT: «(2 6)␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

# Raise 2 to the 81st power, because 3 to the 4th power is 81
(2,3,4).reduce(&infix:<**>).lsb.say;  # OUTPUT: «81␤»
(2**(3**4)).lsb.say;                  # OUTPUT: «81␤»
(2**3**4).lsb.say;                    # OUTPUT: «81␤»
Output
81
81
81

Documentation, Rakudo and Raku++ all agree.

# Subtract 4 from -1, because 2 minus 3 is -1
(2,3,4).reduce(&infix:<->).say;       # OUTPUT: «-5␤»
((2-3)-4).say;                        # OUTPUT: «-5␤»
(2-3-4).say;                          # OUTPUT: «-5␤»
Output
-5
-5
-5

Documentation, Rakudo and Raku++ all agree.

say [*] (1, 2, 3, 4);       # OUTPUT: «24␤»
say [min] (4, 2, 1, 3);     # OUTPUT: «1␤»
Output
24
1

Documentation, Rakudo and Raku++ all agree.

sub mult { $^a * $^b };
say [[&mult]] (1, 2, 3, 4); # OUTPUT: «24␤»
Documentation
24
Rakudo
24
Raku++
[[&mult]]

Raku++ disagrees with both the documentation and Rakudo — a defect.

my \numbers = 1, 2, 3, 4, 5;
say reduce { $^a + $^b }, 0, |numbers;
say reduce * + *, 0, |numbers;
say reduce &[+], numbers; # operator does not need explicit identity value
say [+] numbers;

Not executed: the documentation states no expected output for this example.

sub last-after-seven { last if $^a > 7; $^a + $^b };
say (2, 3, 4, 5).reduce: &last-after-seven; # OUTPUT: «9␤»
Output
9

Documentation, Rakudo and Raku++ all agree.

sub infix:<foo>($a, $b) is assoc<right> { "($a, $b)" }
say [foo] 1, 2, 3, 4; # OUTPUT: «(1, (2, (3, 4)))␤»
Documentation
(1, (2, (3, 4)))
Rakudo
(1, (2, (3, 4)))
Raku++
(((1, 2), 3), 4)

Raku++ disagrees with both the documentation and Rakudo — a defect.

sub infix:<bar>($a, $b) is assoc<left> { "($a, $b)" }
say [bar] 1, 2, 3, 4; # OUTPUT: «(((1, 2), 3), 4)␤»
Output
(((1, 2), 3), 4)

Documentation, Rakudo and Raku++ all agree.

my @ops = [Z] (<+ - * />, 1..20)».roll(4);

Not executed: the documentation states no expected output for this example.

say ('x', |@ops).reduce: -> $formula, [$op, $number] {
    Bool.pick ?? "($formula $op $number)"
              !! "($number $op $formula)"
}

Not executed: the documentation states no expected output for this example.

sub evaluate(List:D \c where c.all ~~ Int, Rat:D \x --> Rat:D) {
    my \xi = (c.elems ^... 0).map: -> \i { x ** i }; # [x^(n-1), ..., x^0]
    my \axi = [+] c Z* xi;                           # [c[n-1]*x^(n-1), ..., c[*]x^0]
    [+] axi;                                         # sum of axi
}

Not executed: the documentation states no expected output for this example.

my \c = 2, 3, 1;       # 2x² + 3x + 1
say evaluate c, 3.0;   # OUTPUT: «28␤»
say evaluate c, 10.0;  # OUTPUT: «231␤»

Neither engine can run this in isolation — the example depends on context from the surrounding text.

# Raise 2 to the 81st power, because 3 to the 4th power is 81
[2,3,4].produce(&[**]).say;        # OUTPUT: «(4 81 2417851639229258349412352)␤»
say produce &[**], (2,3,4);        # OUTPUT: «(4 81 2417851639229258349412352)␤»
say [\**] (2,3,4);                 # OUTPUT: «(4 81 2417851639229258349412352)␤»
Output
(4 81 2417851639229258349412352)
(4 81 2417851639229258349412352)
(4 81 2417851639229258349412352)

Documentation, Rakudo and Raku++ all agree.

# Subtract 4 from -1, because 2 minus 3 is -1
[2,3,4].produce(&[-]).say;         # OUTPUT: «(2 -1 -5)␤»
say produce &[-], (2,3,4);         # OUTPUT: «(2 -1 -5)␤»
say [\-] (2,3,4);                  # OUTPUT: «(2 -1 -5)␤»
Output
(2 -1 -5)
(2 -1 -5)
(2 -1 -5)

Documentation, Rakudo and Raku++ all agree.

# The following all do the same thing...
my @numbers = (1,2,3,4,5);
say produce { $^a + $^b }, @numbers;
say produce * + *, @numbers;
say produce &[+], @numbers; # operator does not need explicit identity
say [\+] @numbers;          # most people write it this way

Not executed: the documentation states no expected output for this example.

[\,] 1..5;
# (
# (1)
# (1 2)
# (1 2 3)
# (1 2 3 4)
# (1 2 3 4 5)
# )

Not executed: the documentation states no expected output for this example.

say (2,3,4,5).produce: { last if $^a > 7; $^a + $^b }; # OUTPUT: «(2 5 9)␤»
Documentation
(2 5 9)
Rakudo
(2 5)
Raku++
(2 5)

Both engines agree; the documentation states something else. Trust the engines.

.say for <a b c>.combinations: 2;
# OUTPUT:
# (a b)
# (a c)
# (b c)

Not executed: the documentation states no expected output for this example.

.say for <a b c>.combinations: 2..3;
# OUTPUT:
# (a b)
# (a c)
# (b c)
# (a b c)

Not executed: the documentation states no expected output for this example.

.say for combinations 3, 2
# OUTPUT:
# (0 1)
# (0 2)
# (1 2)

Not executed: the documentation states no expected output for this example.

.say for <a b c>.permutations;
# OUTPUT:
# (a b c)
# (a c b)
# (b a c)
# (b c a)
# (c a b)
# (c b a)

Not executed: the documentation states no expected output for this example.

.say for permutations 3;
# OUTPUT:
# (0 1 2)
# (0 2 1)
# (1 0 2)
# (1 2 0)
# (2 0 1)
# (2 1 0)

Not executed: the documentation states no expected output for this example.

say ('a'..'h').rotor(3).join('|');              # OUTPUT: «a b c|d e f␤»
say ('a'..'h').rotor(3, :partial).join('|');    # OUTPUT: «a b c|d e f|g h␤»
Output
a b c|d e f
a b c|d e f|g h

Documentation, Rakudo and Raku++ all agree.

say ('a'..'h').rotor(2 => 1).join('|');         # OUTPUT: «a b|d e|g h␤»
say ('a'..'h').rotor(3 => -1).join('|');        # OUTPUT: «a b c|c d e|e f g␤»
Output
a b|d e|g h
a b c|c d e|e f g

Documentation, Rakudo and Raku++ all agree.

say ('a'..'h').rotor(2, 3).join('|');           # OUTPUT: «a b|c d e|f g␤»
say ('a'..'h').rotor(1 => 1, 3).join('|');      # OUTPUT: «a|c d e|f␤»
Output
a b|c d e|f g
a|c d e|f

Documentation, Rakudo and Raku++ all agree.

say ('a'..'h').rotor(1 => 1, 3 => -1, :partial).join('|');
# OUTPUT: «a|c d e|e|g h␤»
Output
a|c d e|e|g h

Documentation, Rakudo and Raku++ all agree.

multi rotor(Int:D $batch, \thing, Bool() :$partial --> Seq:D)

Not executed: the documentation states no expected output for this example.

multi rotor(**@cycle, \thing, Bool() :$partial --> Seq:D)

Not executed: the documentation states no expected output for this example.

say rotor(3, 'a'..'h').join('|');             # OUTPUT: «a b c|d e f␤»
say rotor(3, 'a'..'h', :partial).join('|');   # OUTPUT: «a b c|d e f|g h␤»
say rotor(2 => 1, 'a'..'h').join('|');        # OUTPUT: «a b|d e|g h␤»
say rotor(3 => -1, 'a'..'h').join('|');       # OUTPUT: «a b c|c d e|e f g␤»
say rotor(1 => 1, 3 => -1, 'a'..'h', :partial).join('|');
# OUTPUT: «a|c d e|e|g h␤»
Output
a b c|d e f
a b c|d e f|g h
a b|d e|g h
a b c|c d e|e f g
a|c d e|e|g h

Documentation, Rakudo and Raku++ all agree.

say cross(<a b c>, <d e f>).map(*.join).join(",")
# OUTPUT: «ad,ae,af,bd,be,bf,cd,ce,cf␤»
Output
ad,ae,af,bd,be,bf,cd,ce,cf

Documentation, Rakudo and Raku++ all agree.

say (<a b c> X <d e f>).map(*.join).join(",")
# output is the same as the previous example

Not executed: the documentation states no expected output for this example.

say cross([1, 2, 3], [4, 5, 6], :with(&infix:<*>)).join(",");
# OUTPUT: «4,5,6,8,10,12,12,15,18␤»
Output
4,5,6,8,10,12,12,15,18

Documentation, Rakudo and Raku++ all agree.

say ([1, 2, 3] X* [4, 5, 6]).join(",")
# same output as the previous example

Not executed: the documentation states no expected output for this example.

say zip(<a b c>, <d e f>, <g h i>);
# OUTPUT: «((a d g) (b e h) (c f i))␤»
Output
((a d g) (b e h) (c f i))

Documentation, Rakudo and Raku++ all agree.

say <a b c> Z <d e f> Z <g h i>;                   # same output

Not executed: the documentation states no expected output for this example.

for <a b c> Z <d e f> Z <g h i> -> [$x,$y,$z] {say ($x,$y,$z).join(",")}
# OUTPUT: «a,d,g␤b,e,h␤c,f,i␤»
Output
a,d,g
b,e,h
c,f,i

Documentation, Rakudo and Raku++ all agree.

say .join(",") for zip <a b c>, <d e f>, <g h i>;  # same output

Not executed: the documentation states no expected output for this example.

say <a b c> Z <d e f m n o p> Z <g h i>;
# ((a d g) (b e h) (c f i))

Not executed: the documentation states no expected output for this example.

.say for zip <1 2 3>, [1, 2, 3], (1, 2, 3), :with(&infix:<*>);
# OUTPUT: «1␤8␤27␤»
Output
1
8
27

Documentation, Rakudo and Raku++ all agree.

.say for <1 2 3> Z* [1, 2, 3] Z* (1, 2, 3);        # same output

Not executed: the documentation states no expected output for this example.

say roundrobin <a b c>, <d e f>, <g h i>;
# OUTPUT: «((a d g) (b e h) (c f i))␤»
Output
((a d g) (b e h) (c f i))

Documentation, Rakudo and Raku++ all agree.

say .join(",") for roundrobin([1, 2], [2, 3], [3, 4]);
# OUTPUT: «1,2,3␤2,3,4␤»
Output
1,2,3
2,3,4

Documentation, Rakudo and Raku++ all agree.

say roundrobin <a b c>, <d e f m n o p>, <g h i j>;
# OUTPUT: «((a d g) (b e h) (c f i) (m j) (n) (o) (p))␤»
Output
((a d g) (b e h) (c f i) (m j) (n) (o) (p))

Documentation, Rakudo and Raku++ all agree.

say .join(",") for roundrobin([1, 2], [2, 3, 57, 77], [3, 4, 102]);
# OUTPUT: «1,2,3␤2,3,4␤57,102␤77␤»
Output
1,2,3
2,3,4
57,102
77

Documentation, Rakudo and Raku++ all agree.

sub roundrobin(+list-of-lists, :$slip --> Seq)

Not executed: the documentation states no expected output for this example.

say roundrobin <a b c>, <d e f m n o p>, <g h i j>, :slip;
# OUTPUT: «(a d g b e h c f i m j n o p)␤»
Output
(a d g b e h c f i m j n o p)

Documentation, Rakudo and Raku++ all agree.

say (1, 3, pi).sum;       # OUTPUT: «7.14159265358979␤»
say (1, "0xff").sum;      # OUTPUT: «256␤»
say sum(0b1111, 5);       # OUTPUT: «20␤»
Documentation
7.14159265358979
256
20
Rakudo
7.141592653589793
256
20
Raku++
7.141592653589793
256
20

Both engines agree; the documentation states something else. Trust the engines.

say ( 1|2, 3).sum;            # OUTPUT: «any(4, 5)␤»
Output
any(4, 5)

Documentation, Rakudo and Raku++ all agree.

my int @a = ^1_000_000;
say @a.sum(:wrap);        # OUTPUT: «499999500000␤»
Documentation
499999500000
Rakudo
Raku++
499999500000

Raku++ matches the documentation; Rakudo does not. This is the one class where neither engine can be assumed right: it may be a stale doc that Raku++ was built from, or it may be a Rakudo bug that the documentation predates. Each case is examined individually.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

my @a = 8..11;
say @a.fmt('%03d', ',');  # OUTPUT: «008,009,010,011␤»
Output
008,009,010,011

Documentation, Rakudo and Raku++ all agree.

'abcdefg' ~~ /(c)(d)/;
say $/.list.from;         # OUTPUT: «2␤»
Output
2

Documentation, Rakudo and Raku++ all agree.

"abc123def" ~~ m:g/\d/;
say $/.list.from;         # OUTPUT: «3␤»
Output
3

Documentation, Rakudo and Raku++ all agree.

"abc123def" ~~ m:g/\d/;
say $/.to; # OUTPUT: «6␤»
Output
6

Documentation, Rakudo and Raku++ all agree.

sink [1,2,Failure.new("boo!"),"still here"]; # OUTPUT: «»

Not executed: the documentation states no expected output for this example.

say <æ ß þ €>.Set;  # OUTPUT: «Set(ß æ þ €)␤»
Output
Set(ß æ þ €)

Documentation, Rakudo and Raku++ all agree.

my @a = (:42a, :33b);
say @a;                # OUTPUT: «[a => 42 b => 33]␤»
say @a.Set;            # OUTPUT: «Set(a b)␤»
Output
[a => 42 b => 33]
Set(a b)

Documentation, Rakudo and Raku++ all agree.

say (1, 2, 3) cmp (1, 2, 3);   # OUTPUT: «Same␤»
say (4, 5, 6) cmp (4, 5, 7);   # OUTPUT: «Less␤»
say (7, 8, 9) cmp (7, 8, 8);   # OUTPUT: «More␤»
Output
Same
Less
More

Documentation, Rakudo and Raku++ all agree.

say (1, 2)    cmp (1, 2, 3);   # OUTPUT: «Less␤»
say (1, 2, 3) cmp (1, 2);      # OUTPUT: «More␤»
say (9).List  cmp (^10).List;  # OUTPUT: «More␤»
Output
Less
More
More

Documentation, Rakudo and Raku++ all agree.