class Array

Sequence of itemized values

class Array is List {}

An Array is a List which forces all its elements to be scalar containers, which means you can assign to array elements.

Array implements Positional and as such provides support for subscripts.


routine pop

Defined as:

multi sub    pop(Array:D )
multi method pop(Array:D:)

Removes and returns the last item from the array. Fails for an empty array.


my @foo = <a b># a b 
@foo.pop;        # b 
pop @foo;        # a 
pop @foo;
CATCH { default { put .^name''.Str } };
# OUTPUT: «X::Cannot::Empty: Cannot pop from an empty Array␤» 

routine push

Defined as:

multi sub    push(Array:D**@values --> Array:D)
multi method push(Array:D: **@values --> Array:D)

Adds the @values to the end of the array, and returns the modified list. Throws for lazy arrays.


my @foo = <a b c>;
@foo.push: 'd';
say @foo;                   # OUTPUT: «[a b c d]␤» 

Note that push does not attempt to flatten its argument list. If you pass an array or list as the thing to push, it becomes one additional element:

my @a = <a b c>;
my @b = <d e f>;
@a.push: @b;
say @a.elems;               # OUTPUT: «4␤» 
say @a[3].join;             # OUTPUT: «def␤» 

Only if you supply multiple values as separate arguments to push are multiple values added to the array:

my @a = '1';
my @b = <a b>;
my @c = <E F>;
@a.push: @b@c;
say @a.elems;                # OUTPUT: «3␤» 

See method append for when you want to append multiple values that are stored in a single array.

method append

Defined as

sub append(\arrayelems)
multi method append(Array:D: \values)
multi method append(Array:D: **@values is raw)

Appends the argument list to the array passed as the first argument. This modifies the array in-place. Returns the modified array. Throws for lazy arrays.

The difference from method push is that with an array or list argument, append appends several elements (one for each array or list element), whereas push appends just one element.


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]␤» 

method elems

Defined as:

method elems(Array:D: --> Int:D)

Returns the number of elements in the invocant. Throws X::Cannot::Lazy exception if the invocant is lazy. For shaped arrays, returns the outer dimension; see shape if you need information for all dimensions.

say [<foo bar ber>.elems# OUTPUT: «3␤» 
say (my @a[42;3;70]).elems# OUTPUT: «42␤» 
try [-∞...∞].elems;
say $!.^name;               # OUTPUT: «X::Cannot::Lazy␤» 

method clone

Defined as:

method clone(Array:D: --> Array:D)

Clones the original Array. Modifications of elements in the clone are not propagated to the original and vice-versa:

my @a = <a b c>my @b = @a.clone;
@b[1= 42@a.push: 72;
say @b# OUTPUT: «[a 42 c]␤» 
say @a# OUTPUT: «[a b c 72]␤» 

However, note that the reifier is shared between the two Arrays, so both Arrays will have the same elements even when each is randomly-generated on reification and each element will be reified just once, regardless of whether the reification was done by the clone or the original Array. Note: just as reifying an Array from multiple threads is not safe, so is, for example, reifying the clone from one thread while reifying the original from another thread is not safe.

my @a = 1{rand} … ∞; my @b = @a.clone;
say @b[^3]; # OUTPUT: «(1 0.0216426755282736 0.567660896142156)␤» 
say @a[^3]; # OUTPUT: «(1 0.0216426755282736 0.567660896142156)␤» 

routine shift

Defined as:

multi sub    shift(Array:D )
multi method shift(Array:D:)

Removes and returns the first item from the array. Fails for an empty arrays.


my @foo = <a b>;
say @foo.shift;             # OUTPUT: «a␤» 
say @foo.shift;             # OUTPUT: «b␤» 
say @foo.shift;
CATCH { default { put .^name''.Str } };
# OUTPUT: «X::Cannot::Empty: Cannot shift from an empty Array␤» 

routine unshift

Defined as:

multi sub    unshift(Array:D**@values --> Array:D)
multi method unshift(Array:D: **@values --> Array:D)

Adds the @values to the start of the array, and returns the modified array. Fails if @values is infinite.


my @foo = <a b c>;
@foo.unshift: 13 ... 11;
say @foo;                   # OUTPUT: «[(1 3 5 7 9 11) a b c]␤» 

The notes in the documentation for method push apply, regarding how many elements are added to the array.

method prepend is the equivalent for adding multiple elements from one list or array.

method prepend

Defined as

sub prepend(\arrayelems)
multi method prepend(Array:D: \values)
multi method prepend(Array:D: **@values is raw)

Adds the elements from LIST to the front of the array, modifying it in-place.


my @foo = <a b c>;
@foo.prepend: 13 ... 11;
say @foo;                   # OUTPUT: «[1 3 5 7 9 11 a b c]␤» 

routine splice

Defined as:

multi sub    splice(@list,  $start$elems?*@replacement --> Array)
multi method splice(Array:D $start$elems?*@replacement --> Array)

Deletes $elems elements starting from index $start from the Array, returns them and replaces them by @replacement. If $elems is omitted, all the elements starting from index $start are deleted.

Each of $start and $elems can be specified as a Whatever or as a Callable that returns an int-compatible value.

A Whatever $start uses the number of elements of @list (or invocant). A Callable $start is called with one argument—the number of elements in @list—and its return value is used as $start.

A Whatever $elems deletes from $start to end of @list (same as no $elems). A Callable $elements is called with just one argument—the number of elements in @list minus the value of $start—and its return value is used the value of $elems.


my @foo = <a b c d e f g>;
say @foo.splice(23, <M N O P>);        # OUTPUT: «[c d e]␤» 
say @foo;                                # OUTPUT: «[a b M N O P f g]␤» 

method shape

Defined as:

method shape() { (*,) }

Returns the shape of the array as a list.


my @foo[2;3= ( < 1 2 3 >, < 4 5 6 > ); # Array with fixed dimensions 
say @foo.shape;                          # OUTPUT: «(2 3)␤» 
my @bar = ( < 1 2 3 >, < 4 5 6 > );      # Normal array (of arrays) 
say @bar.shape;                          # OUTPUT: «(*)␤» 

method default

Defined as:

method default

Returns the default value of the invocant, i.e. the value which is returned when trying to access an element in the Array which has not been previously initialized or when accessing an element which has explicitly been set to Nil. Unless the Array is declared as having a default value by using the is default trait the method returns the type object (Any).

my @a1 = 1"two"2.718;
say @a1.default;                                       # OUTPUT: «(Any)␤» 
say @a1[4];                                            # OUTPUT: «(Any)␤» 
my @a2 is default(17= 1"two"3;
say @a2.default;                                       # OUTPUT: «17␤» 
say @a2[4];                                            # OUTPUT: «17␤» 
@a2[1= Nil;                                          # (resets element to its default) 
say @a2[1];                                            # OUTPUT: «17␤» 

method of

Defined as:

method of

Returns the type constraint for the values of the invocant. By default, i.e. if no type constraint is given during declaration, the method returns (Mu).

my @a1 = 1'two'3.14159;              # (no type constraint specified) 
say @a1.of;                              # OUTPUT: «(Mu)␤» 
my Int @a2 = 123;                    # (values must be of type Int) 
say @a2.of;                              # OUTPUT: «(Int)␤» 
@a2.push: 'd';
CATCH { default { put .^name''.Str } };
# OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to @a2; expected Int but got Str ("d")␤» 

Type graph

Type relations for Array
perl6-type-graph Array Array List List Array->List Mu Mu Any Any Any->Mu Cool Cool Cool->Any Positional Positional Iterable Iterable List->Cool List->Positional List->Iterable

Stand-alone image: vector

Routines supplied by class List

Array inherits from class List, which provides the following methods:

(List) routine elems

Defined as:

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

Returns the number of elements in the list.

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

(List) routine end

Defined as:

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

Returns the index of the last element.

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

(List) routine keys

Defined as:

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

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

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

(List) routine values

Defined as:

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

Returns a sequence of the list elements, in order.

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

(List) routine kv

Defined as:

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

Returns an interleaved sequence of indexes and values. For example

<a b c>.kv# (0 a 1 b 2 c) 

(List) routine pairs

Defined as:

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

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

<a b c>.pairs   # (0 => a 1 => b 2 => c) 

(List) routine antipairs

Defined as:

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

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

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

(List) routine join

Defined as:

sub    join($separator*@list --> Str:D)
method join(List:D: $separator --> Str:D)

Treats the elements of the list as strings, interleaves them with $separator and concatenates everything into a single string.


join '', <a b c>;             # RESULT: «a, b, c» 

Note that the method form does not flatten sublists:

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

(List) routine map

Defined as:

sub    map(&code*@elems --> Seq:D)
method map(List:D: &code --> Seq:D)

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:

say ('hello'122/742'world').map: { .WHAT.perl } # OUTPUT: «(Str Int Rat Int Str)␤» 
say map *.Str.chars'hello'122/742'world';     # OUTPUT: «(5 1 8 2 5)␤» 

map inspects the arity of the code object, and tries to pass as many arguments to it as expected:

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

iterates the list two items at a time.

Note that map does not flatten embedded lists and arrays, so

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

passes (1, 2) and <a b> in turn to the block, leading to a total of two iterations and the result sequence "1,2", "a,b". See method flatmap for an alternative that flattens.

If &code is a Block loop phasers will be executed and loop control statements will be treated as in loop control flow. Please note that return is executed in the context of its definition. It is not the return statement of the block but the surrounding Routine. Using a Routine will also handle loop control statements and loop phasers. Any Routine specific control statement or phaser will be handled in the context of that Routine.

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

(List) sub flat

Defined as:

sub flat(**@list is raw)

Constructs a list which contains any arguments provided in the order provided, and returns the result of calling the .flat method (inherited from Any) on that list:

say flat 1, (2, (34), $(56)); # OUTPUT: «(1 2 3 4 (5 6))␤» 

(List) method flatmap

Defined as:

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

Like map iterates over the elements of the invocant list, feeding each element in turn to the code reference, and assembling the return values from these invocations in a result list.

Unlike map it flattens non-itemized lists and arrays, so

say ((12), <a b>).flatmap(&uc).join('|');     # OUTPUT: «1 2|A B␤» 

invokes uc four times.

(List) method gist

Defined as:

multi method gist(List:D: --> 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 '(...)'

    put (123).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 ...) 

(List) routine grep

Defined as:

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

Returns a sequence of elements against which $matcher smart-matches. The elements are returned in the order in which they appear in the original list.


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

The optional named parameters :k, :kv, :p, :v provide the same functionality as on slices:

  • k

  • Only return the index values of the matching elements in order.

  • kv

  • Return both the index and matched elements in order.

  • p

  • Return the index and the matched element as a Pair, in order.

  • v

  • Only return the matched elements (same as not specifying any named parameter at all).


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

    (List) routine first

    Defined as:

    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 smart-matches 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.


    say (122/742300).first: * > 5;                  # OUTPUT: «42␤» 
    say (122/742300).first: * > 5:end;            # OUTPUT: «300␤» 
    say ('hello'122/742'world').first: Complex;   # OUTPUT: «Nil␤» 

    The optional named parameters :k, :kv, :p provide the same functionality as on slices:

  • k

  • Return the index value of the matching element. Index is always counted from the beginning of the list, regardless of whether the :end named parameter is specified or not.

  • kv

  • Return both the index and matched element.

  • p

  • Return the index and the matched element as a Pair.


    say (122/742300).first: * > 5:k;        # OUTPUT: «2␤» 
    say (122/742300).first: * > 5:p;        # OUTPUT: «2 => 42␤» 
    say (122/742300).first: * > 5:kv:end# OUTPUT: «(3 300)␤» 

    In method form, the $matcher can be omitted, in which case the first available item (or last if :end is set) will be returned. See also head and tail methods.

    (List) method head

    Defined as:

    method head(List:D: Int(Cool$number = 1 --> Seq:D)

    Returns the first NUMBER items of the list. Returns an empty list if NUMBER <= 0. Defaults to the first element seen if no NUMBER specified.


    say ^10 .head(5);      # OUTPUT: «(0 1 2 3 4)␤» 
    say ^Inf .head(5);     # OUTPUT: «(0 1 2 3 4)␤» 
    say ^10 .head;         # OUTPUT: «(0)␤» 
    say ^Inf .head;        # OUTPUT: «(0)␤» 

    (List) method tail

    Defined as:

    method tail(List:D: Int(Cool$number = 1 --> Seq:D)

    Returns a Seq containing the last NUMBER items of the list. Returns an empty Seq if NUMBER <= 0. Defaults to the last element if no NUMBER is specified. Throws an exception if the list is lazy.


    say ^10 .tail(5);      # OUTPUT: «(5 6 7 8 9)␤» 
    say ^Inf .tail(5);     # Cannot tail a lazy list 
    say ^10 .tail;         # OUTPUT: «(9)␤» 
    say ^Inf .tail;        # Cannot tail a lazy list 

    (List) routine categorize

    Defined as:

    sub    categorize(&mapper*@values --> Hash:D)
    method categorize(List:D: &mapper   --> Hash:D)

    Transforms a list of values into a hash representing the categorizations of those values according to a mapper; each hash key represents one possible categorization for one or more of the incoming list values, and the corresponding hash value contains an array of those list values categorized by the mapper into the category of the associated key.

    Note that, unlike classify, which assumes that the return value of the mapper is a single value, categorize always assumes that the return value of the mapper is a list of categories that are appropriate to the current value.


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

    (List) routine classify

    Defined as:

    sub    classify(&mapper*@values --> Hash:D)
    method classify(List:D: &mapper   --> Hash:D)

    Transforms a list of values into a hash representing the classification of those values according to a mapper; 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 by the mapper into the category of the associated key.


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

    (List) method Bool

    Defined as:

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

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

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

    (List) method Str

    Defined as:

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

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

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

    (List) method Int

    Defined as:

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

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

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

    (List) method Numeric

    Defined as:

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

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

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

    (List) method Capture

    Defined as:

    method Capture(--> 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 positional argument, getting index 1 etc.

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

    A more advanced example demonstrating the returned Capture being matched against a Signature.

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

    (List) routine pick

    Defined as:

    multi sub    pick($count*@list --> Seq:D)
    multi method pick(List:D: $count --> Seq:D)
    multi method pick(List:D: --> 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.

    In method form, if $count is omitted: Returns a single random item from the list, or Nil if the list is empty


    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)␤» 

    (List) routine roll

    Defined as:

    multi sub    roll($count*@list --> Seq:D)
    multi method roll(List:D: $count --> Seq:D)
    multi method roll(List:D: --> 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


    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 
    my $random-digits := (^10).roll(*);
    say $random-digits[^15];    # 15 random digits 

    (List) routine eager

    Defined as:

    multi method eager(List:D: --> List:D)
    multi sub eager(*@elems --> List:D)

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

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

    (List) routine reverse

    Defined as:

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

    Returns a Seq say reverse ^10; # OUTPUT: «(9 8 7 6 5 4 3 2 1 0)␤»

    (List) routine rotate

    Defined as:

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

    Returns the list rotated by $n elements.


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

    (List) routine sort

    Defined as:

    multi sub    sort(*@elems      --> Seq:D)
    multi sub    sort(&by*@elems --> Seq:D)
    multi method sort(List:D:      --> Seq:D)
    multi method sort(List:D: &by  --> Seq:D)

    Sorts the list, smallest element first. By default infix:<cmp> is used for comparing list elements.

    If &by 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 &by accepts only one argument, the list elements are sorted according to by($a) cmp by($b) . The return values of &by are cached, so that &by is only called once per list element.


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

    (List) routine unique

    Defined as:

    multi sub    unique(*@values:&as:&with --> Seq:D)
    multi method unique(List:D:  :&as:&with --> Seq:D)

    Returns a sequence of unique values from the invocant/argument list, such that only the first occurrence of each duplicated value remains in the result list. unique uses the semantics of the === operator to decide whether two objects are the same, unless the optional :with parameter is specified with another comparator. The order of the original list is preserved even as duplicates are removed.


    say <a a b b b c c>.unique;   # OUTPUT: «(a b c)␤» 
    say <a b b c c b a>.unique;   # OUTPUT: «(a b c)␤» 

    (Use squish instead if you know the input is sorted such that identical objects are adjacent.)

    The optional :as parameter allows you to normalize/canonicalize the elements before unique-ing. The values are transformed for the purposes of comparison, but it's still the original values that make it to the result list:


    say <a A B b c b C>.unique(:as(&lc))          # OUTPUT: «(a B c)␤» 

    One can also specify the comparator with the optional :with parameter. For instance if one wants a list of unique hashes, one could use the eqv comparator.


    my @list = {=> 42}{=> 13}{=> 42};
    say @list.unique(:with(&[eqv]))               # OUTPUT: «({a => 42} {b => 13})␤» 

    Note: since :with Callable has to be tried with all the items in the list, this makes unique follow a path with much higher algorithmic complexity. You should try to use the :as argument instead, whenever possible.

    (List) routine repeated

    Defined as:

    multi sub    repeated(*@values:&as:&with --> Seq:D)
    multi method repeated(List:D:  :&as:&with --> Seq:D)

    Returns a sequence of repeated values from the invocant/argument list. It takes the same parameters as unique, but instead of passing through any elements when they're first seen, they're only passed through as soon as they're seen for the second time (or more).


    say <a a b b b c c>.repeated;                   # OUTPUT: «(a b b c)␤» 
    say <a b b c c b a>.repeated;                   # OUTPUT: «(b c b a)␤» 
    say <a A B b c b C>.repeated(:as(&lc));         # OUTPUT: «(A b b C)␤» 
    my @list = {=> 42}{=> 13}{=> 42};
    say @list.repeated(:with(&[eqv]))               # OUTPUT: «({a => 42})␤» 

    (List) routine squish

    Defined as:

    multi sub    squish(*@values:&as --> Seq:D)
    multi method squish(List:D:  :&as --> Seq:D)

    Returns a sequence of values from the invocant/argument list where runs of more than one value are replaced with only the first instance. Like unique, squish uses the semantics of the === operator to decide whether two objects are the same. Unlike unique, this function only removes adjacent duplicates; identical values further apart are still kept. The order of the original list is preserved even as duplicates are removed.


    say <a a b b b c c>.squish# OUTPUT: «(a b c)␤» 
    say <a b b c c b a>.squish# OUTPUT: «(a b c b a)␤» 

    The optional :as parameter, just like with unique, allows values to be temporarily transformed before comparison.

    (List) routine reduce

    Defined as:

    multi sub    reduce(&with*@values)
    multi method reduce(List:D: &with)

    Generates a single "combined" value from a list of arbitrarily many of values, by iteratively applying a function which knows how to combine two values.

    If @values contains just a single element, that element is returned immediately. If it contains no elements, an exception is thrown, unless &with is an operator with a known identity value. For this reason, you may want to prefix the input list with an explicit identity value:

    my @strings = ("One good string!""And one another good string!");
    say reduce { $^a ~ $^b }''|@strings;               # like @strings.join 
    my @numbers = (1,2,3,4,5);
    say reduce { $^a > $^b ?? $^a !! $^b }0|@numbers;  # like @numbers.max 

    If &with is the function object of an operator, its inherent identity value and associativity is respected - in other words, (VAL1, VAL2, VAL3).reduce(&[OP]) is the same as VAL1 OP VAL2 OP VAL3 even for operators which aren't left-associative:

    # Raise 2 to the 81st power, because 3 to the 4th power is 81 
    [2,3,4].reduce(&[**]).lsb.say;        # OUTPUT: «81␤» 
    (2**(3**4)).lsb.say;                  # OUTPUT: «81␤» 
    (2**3**4).lsb.say;                    # OUTPUT: «81␤» 
    # Subtract 4 from -1, because 2 minus 3 is -1 
    [2,3,4].reduce(&[-]).say;             # OUTPUT: «-5␤» 
    ((2-3)-4).say;                        # OUTPUT: «-5␤» 
    (2-3-4).say;                          # OUTPUT: «-5␤» 

    Since reducing with an infix operator is a common thing to do, the [ ] meta-operator provides a syntactic shortcut:

    # The following all do the same thing... 
    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 
    say [+@numbers;          # most people write it this way 

    Since reduce is an implicit loop, it responds to next, last and redo statements inside &with:

    say (2,3,4,5).reduce: { last if $^a > 7$^a + $^b }# says 9 

    Practical example:

    # Generate a random-ish math formula like "(4 + ((3 * x) + 11) / 6))" 
    my @ops = [Z] (<+ - * />1..20.roll(4);
    say ('x'|@ops).reduce: -> $formula, [$op$number{
        Bool.pick ?? "($formula $op $number)"
                  !! "($number $op $formula)"

    Note: In the functional programming world, this operation is generally called a fold. With a right-associative operator it is a right fold, otherwise (and usually) it is a left fold:

    sub infix:<foo>($a$bis assoc<right> { "($a$b)" }
    say [foo1234# OUTPUT: «(1, (2, (3, 4)))␤» 
    sub infix:<bar>($a$bis assoc<left> { "($a$b)" }
    say [bar1234# OUTPUT: «(((1, 2), 3), 4)␤» 

    (List) routine produce

    Defined as:

    multi sub    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 inherent identity value and associativity is respected - in other words, (VAL1, VAL2, VAL3).produce(&[OP]) is the same as VAL1 OP VAL2 OP VAL3 even for operators which aren't left-associative:

    # 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)␤» 
    # 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)␤» 

    A triangle meta-operator [\ ] provides a syntactic shortcut for producing with an infix operator:

    # 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 

    The visual picture of a triangle [\ is not accidental. To produce a triangular list of lists, you can use a "triangular comma":

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

    Since produce is an implicit loop, it responds to next, last and redo statements inside &with:

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

    (List) routine combinations

    Defined as:

    multi sub    combinations($n$k                     --> Seq:D)
    multi method combinations(List:D: Int:D $of          --> Seq:D)
    multi method combinations(List:D: Range:D $of = 0..* --> Seq:D)

    The Int variant returns all $of-combinations of the invocant list. For example

    say .join('|'for <a b c>.combinations(2);
    # OUTPUT: «a|b␤ 
    # a|c␤ 
    # b|c␤» 

    because all the 2-combinations of 'a', 'b', 'c' are ['a', 'b'], ['a', 'c'], ['b', 'c'].

    The Range variant combines all the individual combinations into a single list, so

    say .join('|'for <a b c>.combinations(2..3);
    # OUTPUT: «a|b 
    # a|c␤ 
    # b|c␤ 
    # a|b|c␤» 

    because that's the list of all 2- and 3-combinations.

    The subroutine form combinations($n, $k) is equivalent to (^$n).combinations($k), so

    .say for combinations(42)
    # OUTPUT: «0 1 
    # 0 2␤ 
    # 0 3␤ 
    # 1 2␤ 
    # 1 3␤ 
    # 2 3␤» 

    If $k is negative or is larger than there are items in the given list, an empty list will be returned. If $k is zero, a 1-item list containing an empty list will be returned (there's exactly 1 way to pick no items).

    Note: some implementations may limit the maximum $n. On Rakudo, 64-bit systems have a limit of 2³¹-1 and 32-bit systems have a limit of 2²⁸-1.

    (List) routine permutations

    Defined as:

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

    Returns all possible permutations of a list as a sequence of lists. So

    say .join('|'for <a b c>.permutations
    # OUTPUT: «a|b|c␤ 
    # a|c|b␤ 
    # b|a|c␤ 
    # b|c|a␤ 
    # c|a|b␤ 
    # c|b|a␤» 

    permutations treats all list elements as distinguishable, so (1, 1, 2).permutations still returns a list of 6 elements, even though there are only three distinct permutations.

    The subroutine form permutations($n) is equivalent to (^$n).permutations, so

    .say for permutations 3;
    # OUTPUT: «0 1 2␤ 
    # 0 2 1␤ 
    # 1 0 2␤ 
    # 1 2 0␤ 
    # 2 0 1␤ 
    # 2 1 0␤» 

    (List) method rotor

    Defined as:

    method rotor(*@cycleBool() :$partial --> 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:

    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␤» 

    If the element of @cycle is a Pair instead, the key of the pair specifies the length of the return sublist, and the value the gap between sublists; negative gaps produce overlap:

    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␤» 

    If @cycle contains more than element, rotor cycles through it to find the number of elements for each sublist:

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

    Combining multiple cycles and :partial also works:

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

    See this blog post for more elaboration on rotor.

    (List) routine cross

    sub cross(+@e:&with --> 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.

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

    The cross routine has an infix synonym as well, named X.

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

    If the optional with parameter is passed, it is used as a reduction operation to apply to each of the cross product items.

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

    The X operator can be combined with another operator as a meta-operator to perform a reduction as well:

    say ([123X* [456]).join(",")
    # same output as the previous example 

    (List) routine zip

    Defined as:

    sub zip(+@e:&with --> 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.

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

    zip has an infix synonym, the Z operator.

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

    zip can provide input to a for loop :

    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␤» 

    , or more succinctly:

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

    Note, that if the input lists have an unequal number of elements, then zip terminates once the shortest input list is exhausted, and trailing elements from longer input lists are discarded.

    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)) 

    In cases where data clipping is possible, but undesired, then consider using roundrobin instead of zip.

    The optional with parameter will additionally reduce the zipped lists. For example, the following multiplies corresponding elements together to return a single list of products.

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

    The Z form can also be used to perform reduction by implicitly setting the with parameter with a meta-operator :

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

    (List) sub roundrobin

    Defined as:

    method roundrobin(List:D: --> 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 have an unequal number of elements.

    say roundrobin <a b c>, <d e f>, <g h i>;
    # OUTPUT: «((a d g) (b e h) (c f i))␤» 
    say .join(","for roundrobin([12], [23], [34]);
    # OUTPUT: «1,2,3␤ 
    # 2,3,4␤» 

    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.

    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))␤» 
    say .join(","for roundrobin([12], [235777], [34102]);
    # OUTPUT: «1,2,3␤ 
    # 2,3,4␤ 
    # 57,102␤ 
    # 77␤» 

    Therefore no data values are lost due in the 'zipping' operation. A record of which input list provided which element cannot be gleaned from the resulting sequence, however.

    roundrobin can be useful in combining messy data to the point where a manual post-processing step can then be undertaken.

    (List) routine sum

    Defined as:

    sub    sum($list   --> Numeric:D)
    method sum(List:D: --> Numeric: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.

    say (13pi).sum;       # OUTPUT: «7.14159265358979␤» 
    say (1"0xff").sum;      # OUTPUT: «256␤» 
    say sum(0b11115);       # OUTPUT: «20␤» 

    (List) method fmt

    Defined as:

    method fmt($format = '%s'$separator = ' ' --> 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.

    For more information about formats strings, see sprintf.

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

    (List) method from

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

    'abcdefg' ~~ /(c)(d)/;
    say $/.list.from;         # OUTPUT: «2␤» 
    "abc123def" ~~ m:g/\d/;
    say $/.list.from;         # OUTPUT: «3␤» 

    (List) method to

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

    Assumes the List contains Match objects, 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.

    Methods supplied by role Positional

    Array inherits from class List, which does role Positional, which provides the following methods:

    (Positional) method of

    method of()

    Returns the type constraint for elements of the positional container. Defaults to Mu.

    Methods supplied by role Iterable

    Array inherits from class List, which does role Iterable, which provides the following methods:

    (Iterable) method iterator

    Defined as:

    method iterator(--> Iterator:D)

    Method stub that ensures all classes doing the Iterable role have a method iterator.

    It is supposed to return an Iterator.

    say (1..10).iterator;

    (Iterable) method flat

    Defined as:

    method flat(--> Iterable)

    Returns another Iterable that flattens out all iterables that the first one returns.

    For example

    say (<a b>'c').elems;         # OUTPUT: «2␤» 
    say (<a b>'c').flat.elems;    # OUTPUT: «3␤» 

    because <a b> is a List and thus iterable, so (<a b>, 'c').flat returns ('a', 'b', 'c'), which has three elems.

    Note that the flattening is recursive, so ((("a", "b"), "c"), "d").flat returns ("a", "b", "c", "d"), but it does not flatten itemized sublists:

    say ($('a''b'), 'c').perl;    # OUTPUT: «($("a", "b"), "c")␤» 

    (Iterable) method lazy

    Defined as:

    method lazy(--> Iterable)

    Returns a lazy iterable wrapping the invocant.

    say (1 ... 1000).is-lazy;      # OUTPUT: «False␤» 
    say (1 ... 1000) OUTPUT: «True␤» 

    (Iterable) method hyper

    Defined as:

    method hyper(Int(Cool:$batch = 64Int(Cool:$degree = 4 --> Iterable)

    Returns another Iterable that is potentially iterated in parallel, with a given batch size and degree of parallelism.

    The order of elements is preserved.

    say ([1..100]{ $_ +1 }).list);

    (Iterable) method race

    Defined as:

    method race(Int(Cool:$batch = 64Int(Cool:$degree = 4 --> Iterable)

    Returns another Iterable that is potentially iterated in parallel, with a given batch size and degree of parallelism (number of parallel workers).

    Unlike hyper, race does not preserve the order of elements.

    say ([1..100]{ $_ +1 }).list);

    Routines supplied by class Cool

    Array inherits from class Cool, which provides the following methods:

    (Cool) routine abs

    Defined as:

    sub abs(Numeric() $x)
    method abs()

    Coerces the invocant (or in the sub form, the argument) to Numeric and returns the absolute value (that is, a non-negative number).

    say (-2).abs;       # OUTPUT: «2␤» 
    say abs "6+8i";     # OUTPUT: «10␤» 

    (Cool) method conj

    Defined as:

    method conj()

    Coerces the invocant to Numeric and returns the complex conjugate (that is, the number with the sign of the imaginary part negated).

    say (1+2i).conj;        # OUTPUT: «1-2i␤» 

    (Cool) routine sqrt

    Defined as:

    sub sqrt(Numeric(Cool$x)
    method sqrt()

    Coerces the invocant to Numeric (or in the sub form, the argument) and returns the square root, that is, a non-negative number that, when multiplied with itself, produces the original number.

    say 4.sqrt;             # OUTPUT: «2␤» 
    say sqrt(2);            # OUTPUT: «1.4142135623731␤» 

    (Cool) method sign

    Defined as:

    method sign()

    Coerces the invocant to Numeric and returns its sign, that is, 0 if the number is 0, 1 for positive and -1 for negative values.

    say 6.sign;             # OUTPUT: «1␤» 
    say (-6).sign;          # OUTPUT: «-1␤» 
    say "0".sign;           # OUTPUT: «0␤» 

    (Cool) method rand

    Defined as:

    method rand()

    Coerces the invocant to Num and returns a pseudo-random value between zero and the number.

    say 1e5.rand;           # OUTPUT: «33128.495184283␤» 

    (Cool) routine sin

    Defined as:

    sub sin(Numeric(Cool))
    method sin()

    Coerces the invocant (or in the sub form, the argument) to Numeric, interprets it as radians, returns its sine.

    say sin(0);             # OUTPUT: «0␤» 
    say sin(pi/4);          # OUTPUT: «0.707106781186547␤» 
    say sin(pi/2);          # OUTPUT: «1␤» 

    Note that Perl 6 is no computer algebra system, so sin(pi) typically does not produce an exact 0, but rather a very small floating-point number.

    (Cool) routine asin

    Defined as:

    sub asin(Numeric(Cool))
    method asin()

    Coerces the invocant (or in the sub form, the argument) to Numeric, and returns its arc-sine in radians.

    say 0.1.asin;               # OUTPUT: «0.10016742116156␤» 
    say asin(0.1);              # OUTPUT: «0.10016742116156␤» 

    (Cool) routine cos

    Defined as:

    sub cos(Numeric(Cool))
    method cos()

    Coerces the invocant (or in sub form, the argument) to Numeric, interprets it as radians, returns its cosine.

    say 0.cos;                  # OUTPUT: «1␤» 
    say pi.cos;                 # OUTPUT: «-1␤» 
    say cos(pi/2);              # OUTPUT: «6.12323399573677e-17␤» 

    (Cool) routine acos

    Defined as:

    sub acos(Numeric(Cool))
    method acos()

    Coerces the invocant (or in sub form, the argument) to Numeric, and returns its arc-cosine in radians.

    say 1.acos;                 # OUTPUT: «0␤» 
    say acos(-1);               # OUTPUT: «3.14159265358979␤» 

    (Cool) routine tan

    Defined as:

    sub tan(Numeric(Cool))
    method tan()

    Coerces the invocant (or in sub form, the argument) to Numeric, interprets it as radians, returns its tangent.

    say tan(3);                 # OUTPUT: «-0.142546543074278␤» 
    say 3.tan;                  # OUTPUT: «-0.142546543074278␤» 

    (Cool) routine atan

    Defined as:

    sub atan(Numeric(Cool))
    method atan()

    Coerces the invocant (or in sub form, the argument) to Numeric, and returns its arc-tangent in radians.

    say atan(3);                # OUTPUT: «1.24904577239825␤» 
    say 3.atan;                 # OUTPUT: «1.24904577239825␤» 

    (Cool) routine atan2

    Defined as:

    sub atan2(Numeric() $xNumeric() $y = 1e0)
    method atan2($y = 1e0)

    Coerces the arguments (including the invocant in the method form) to Numeric, and returns their two-argument arc-tangent in radians.

    say atan2(3);               # OUTPUT: «1.24904577239825␤» 
    say 3.atan2;                # OUTPUT: «1.24904577239825␤» 

    (Cool) method sec

    Defined as:

    sub sec(Numeric(Cool))
    method sec()

    Coerces the invocant (or in sub form, its argument) to Numeric, interprets it as radians, returns its secant, that is, the reciprocal of its cosine.

    say 45.sec;                 # OUTPUT: «1.90359440740442␤» 
    say sec(45);                # OUTPUT: «1.90359440740442␤» 

    (Cool) routine asec

    Defined as:

    sub asec(Numeric(Cool))
    method asec()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its arc-secant in radians.

    say 1.asec;                 # OUTPUT: «0␤» 
    say sqrt(2).asec;           # OUTPUT: «0.785398163397448␤» 

    (Cool) routine cosec

    Defined as:

    sub cosec(Numeric(Cool))
    method cosec()

    Coerces the invocant (or in sub form, its argument) to Numeric, interprets it as radians, returns its cosecant, that is, the reciprocal of its sine.

    say 0.45.cosec;             # OUTPUT: «2.29903273150897␤» 
    say cosec(0.45);            # OUTPUT: «2.29903273150897␤» 

    (Cool) routine acosec

    Defined as:

    sub acosec(Numeric(Cool))
    method acosec()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its arc-cosecant in radians.

    say 45.acosec;              # OUTPUT: «0.0222240516182672␤» 
    say acosec(45)              # OUTPUT: «0.0222240516182672␤» 

    (Cool) routine cotan

    Defined as:

    sub cotan(Numeric(Cool))
    method cotan()

    Coerces the invocant (or in sub form, its argument) to Numeric, interprets it as radians, returns its cotangent, that is, the reciprocal of its tangent.

    say 45.cotan;               # OUTPUT: «0.617369623783555␤» 
    say cotan(45);              # OUTPUT: «0.617369623783555␤» 

    (Cool) routine acotan

    Defined as:

    sub acotan(Numeric(Cool))
    method acotan()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its arc-cotangent in radians.

    say 45.acotan;              # OUTPUT: «0.0222185653267191␤» 
    say acotan(45)              # OUTPUT: «0.0222185653267191␤» 

    (Cool) routine sinh

    Defined as:

    sub sinh(Numeric(Cool))
    method sinh()

    Coerces the invocant (or in method form, its argument) to Numeric, and returns its Sine hyperbolicus.

    say 1.sinh;                 # OUTPUT: «1.1752011936438␤» 
    say sinh(1);                # OUTPUT: «1.1752011936438␤» 

    (Cool) routine asinh

    Defined as:

    sub asinh(Numeric(Cool))
    method asinh()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Inverse Sine hyperbolicus.

    say 1.asinh;                # OUTPUT: «0.881373587019543␤» 
    say asinh(1);               # OUTPUT: «0.881373587019543␤» 

    (Cool) routine cosh

    Defined as:

    sub cosh(Numeric(Cool))
    method cosh()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Cosine hyperbolicus.

    say cosh(0.5);              # OUTPUT: «1.12762596520638␤» 

    (Cool) routine acosh

    Defined as:

    sub acosh(Numeric(Cool))
    method acosh()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Inverse Cosine hyperbolicus.

    say acosh(45);              # OUTPUT: «4.4996861906715␤» 

    (Cool) routine tanh

    Defined as:

    sub tanh(Numeric(Cool))
    method tanh()

    Coerces the invocant (or in sub form, its argument) to Numeric, interprets it as radians and returns its Tangent hyperbolicus.

    say tanh(0.5);              # OUTPUT: «0.46211715726001␤» 
    say tanh(atanh(0.5));       # OUTPUT: «0.5␤» 

    (Cool) routine atanh

    Defined as:

    sub atanh(Numeric(Cool))
    method atanh()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Inverse tangent hyperbolicus.

    say atanh(0.5);             # OUTPUT: «0.549306144334055␤» 

    (Cool) routine sech

    Defined as:

    sub sech(Numeric(Cool))
    method sech()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Secant hyperbolicus.

    say 0.sech;                 # OUTPUT: «1␤» 

    (Cool) routine asech

    Defined as:

    sub asech(Numeric(Cool))
    method asech()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Inverse hyperbolic secant.

    say 0.8.asech;              # OUTPUT: «0.693147180559945␤» 

    (Cool) routine cosech

    Defined as:

    sub cosech(Numeric(Cool))
    method cosech()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Hyperbolic cosecant.

    say cosech(pi/2);           # OUTPUT: «0.434537208094696␤» 

    (Cool) routine acosech

    Defined as:

    sub acosech(Numeric(Cool))
    method acosech()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Inverse hyperbolic cosecant.

    say acosech(4.5);           # OUTPUT: «0.220432720979802␤» 

    (Cool) routine cotanh

    Defined as:

    sub cotanh(Numeric(Cool))
    method cotanh()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Hyperbolic cotangent.

    say cotanh(pi);             # OUTPUT: «1.00374187319732␤» 

    (Cool) routine acotanh

    Defined as:

    sub acotanh(Numeric(Cool))
    method acotanh()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns its Inverse hyperbolic cotangent.

    say acotanh(2.5);           # OUTPUT: «0.423648930193602␤» 

    (Cool) routine cis

    Defined as:

    sub cis(Numeric(Cool))
    method cis()

    Coerces the invocant (or in sub form, its argument) to Numeric, and returns cos(argument) + i*sin(argument).

    say cis(pi/4);              # OUTPUT: «0.707106781186548+0.707106781186547i␤» 

    (Cool) routine log

    Defined as:

    multi sub log(Numeric(Cool$numberNumeric(Cool$base?)
    multi method log(Cool:D: Cool:D $base?)

    Coerces the arguments (including the invocant in the method form) to Numeric, and returns its Logarithm to base $base, or to base e (Euler's Number) if no base was supplied (Natural logarithm). Returns NaN if $base is negative. Throws an exception if $base is 1.

    say (e*e).log;              # OUTPUT: «2␤» 

    (Cool) routine log10

    Defined as:

    multi sub log10(Cool(Numeric))
    multi method log10()

    Coerces the invocant (or in the sub form, the invocant) to Numeric, and returns its Logarithm to base 10, that is, a number that approximately produces the original number when raised to the power of 10. Returns NaN for negative arguments and -Inf for 0.

    say log10(1001);            # OUTPUT: «3.00043407747932␤» 

    (Cool) method exp

    Defined as:

    multi sub exp(Cool:D $powCool:D $base?)
    multi method exp(Cool:D: Cool:D $base?)

    Coerces the arguments (including the invocant in the method from) to Numeric, and returns $base raised to the power of the first number. If no $base is supplied, e (Euler's Number) is used.

    say 0.exp;      # OUTPUT: «1␤» 
    say 1.exp;      # OUTPUT: «2.71828182845905␤» 
    say 10.exp;     # OUTPUT: «22026.4657948067␤» 

    (Cool) method unpolar

    Defined as:

    method unpolar(Numeric(Cool))

    Coerces the arguments (including the invocant in the method form) to Numeric, and returns a complex number from the given polar coordinates. The invocant (or the first argument in sub form) is the magnitude while the argument (i.e. the second argument in sub form) is the angle. The angle is assumed to be in radians.

    say sqrt(2).unpolar(pi/4);      # OUTPUT: «1+1i␤» 

    (Cool) routine round

    Defined as:

    multi sub round(Numeric(Cool))
    multi method round(Cool:D: $unit = 1)

    Coerces the invocant (or in sub form, its argument) to Numeric, and rounds it to the unit of $unit. If $unit is 1, rounds to the nearest integer.

    say 1.7.round;          # OUTPUT: «2␤» 
    say 1.07.round(0.1);    # OUTPUT: «1.1␤» 
    say 21.round(10);       # OUTPUT: «20␤» 

    Always rounds up if the number is at mid-point:

    say (−.5 ).round;       # OUTPUT: «0␤» 
    say ( .5 ).round;       # OUTPUT: «1␤» 
    say (−.55).round(.1);   # OUTPUT: «-0.5␤» 
    say ( .55).round(.1);   # OUTPUT: «0.6␤» 

    (Cool) routine floor

    Defined as:

    multi sub floor(Numeric(Cool))
    multi method floor

    Coerces the invocant (or in sub form, its argument) to Numeric, and rounds it downwards to the nearest integer.

    say "1.99".floor;       # OUTPUT: «1␤» 
    say "-1.9".floor;       # OUTPUT: «-2␤» 
    say 0.floor;            # OUTPUT: «0␤» 

    (Cool) routine ceiling

    Defined as:

    multi sub ceiling(Numeric(Cool))
    multi method ceiling

    Coerces the invocant (or in sub form, its argument) to Numeric, and rounds it upwards to the nearest integer.

    say "1".ceiling;        # OUTPUT: «1␤» 
    say "-0.9".ceiling;     # OUTPUT: «0␤» 
    say "42.1".ceiling;     # OUTPUT: «43␤» 

    (Cool) routine truncate

    Defined as:

    multi sub truncate(Numeric(Cool))
    multi method truncate()

    Coerces the invocant (or in sub form, its argument) to Numeric, and rounds it towards zero.

    say 1.2.truncate;       # OUTPUT: «1␤» 
    say truncate -1.2;      # OUTPUT: «-1␤» 

    (Cool) routine ord

    Defined as:

    sub ord(Str(Cool))
    method ord()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the Unicode code point number of the first code point.

    say 'a'.ord;            # OUTPUT: «97␤» 

    The inverse operation is chr.

    Mnemonic: returns an ordinal number

    (Cool) routine chr

    Defined as:

    sub chr(Int(Cool))
    method chr()

    Coerces the invocant (or in sub form, its argument) to Int, interprets it as a Unicode code points, and returns a string made of that code point.

    say '65'.chr;       # OUTPUT: «A␤» 

    The inverse operation is ord.

    Mnemonic: turns an integer into a character.

    (Cool) routine chars

    Defined as:

    sub chars(Str(Cool))
    method chars()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the number of characters in the string. Please note that on the JVM, you currently get codepoints instead of graphemes.

    say 'møp'.chars;    # OUTPUT: «3␤» 

    (Cool) routine codes

    Defined as:

    sub codes(Str(Cool))
    method codes()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the number of Unicode code points.

    say 'møp'.codes;    # OUTPUT: «3␤» 

    (Cool) routine flip

    Defined as:

    sub flip(Str(Cool))
    method flip()

    Coerces the invocant (or in sub form, its argument) to Str, and returns a reversed version.

    say 421.flip;       # OUTPUT: «124␤» 

    (Cool) routine trim

    Defined as:

    sub trim(Str(Cool))
    method trim()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the string with both leading and trailing whitespace stripped.

    my $stripped = '  abc '.trim;
    say "<$stripped>";          # OUTPUT: «<abc>␤» 

    (Cool) routine trim-leading

    Defined as:

    sub trim-leading(Str(Cool))
    method trim-leading()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the string with leading whitespace stripped.

    my $stripped = '  abc '.trim-leading;
    say "<$stripped>";          # OUTPUT: «<abc >␤» 

    (Cool) routine trim-trailing

    Defined as:

    sub trim-trailing(Str(Cool))
    method trim-trailing()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the string with trailing whitespace stripped.

    my $stripped = '  abc '.trim-trailing;
    say "<$stripped>";          # OUTPUT: «<  abc>␤» 

    (Cool) routine lc

    Defined as:

    sub lc(Str(Cool))
    method lc()

    Coerces the invocant (or in sub form, its argument) to Str, and returns it case-folded to lower case.

    say "ABC".lc;       # OUTPUT: «abc␤» 

    (Cool) routine uc

    Defined as:

    sub uc(Str(Cool))
    method uc()

    Coerces the invocant (or in sub form, its argument) to Str, and returns it case-folded to upper case (capital letters).

    say "Abc".uc;       # OUTPUT: «ABC␤» 

    (Cool) routine fc

    Defined as:

    sub fc(Str(Cool))
    method fc()

    Coerces the invocant (or in sub form, its argument) to Str, and returns the result a Unicode "case fold" operation suitable for doing caseless string comparisons. (In general, the returned string is unlikely to be useful for any purpose other than comparison.)

    say "groß".fc;       # OUTPUT: «gross␤» 

    (Cool) routine tc

    Defined as:

    sub tc(Str(Cool))
    method tc()

    Coerces the invocant (or in sub form, its argument) to Str, and returns it with the first letter case-folded to title case (or where not available, upper case).

    say "abC".tc;       # OUTPUT: «AbC␤» 

    (Cool) routine tclc

    Defined as:

    sub tclc(Str(Cool))
    method tclc()

    Coerces the invocant (or in sub form, its argument) to Str, and returns it with the first letter case-folded to title case (or where not available, upper case), and the rest of the string case-folded to lower case..

    say 'abC'.tclc;     # OUTPUT: «Abc␤» 

    (Cool) routine wordcase

    Defined as:

    sub wordcase(Str(Cool$input:&filter = &tclcMu :$where = True)
    method wordcase(:&filter = &tclcMu :$where = True)

    Coerces the invocant (or in sub form, the first argument) to Str, and filters each word that smart-matches against $where through the &filter. With the default filter (first character to upper case, rest to lower) and matcher (which accepts everything), this title-cases each word:

    say "perl 6 programming".wordcase;      # OUTPUT: «Perl 6 Programming␤» 

    With a matcher:

    say "have fun working on perl".wordcase(:where({ .chars > 3 }));
                                            # Have fun Working on Perl 

    With a customer filter too:

    say "have fun working on perl".wordcase(:filter(&uc), :where({ .chars > 3 }));
                                            # HAVE fun WORKING on PERL 

    (Cool) routine samecase

    Defined as:

    sub samecase(Cool $stringCool $pattern)
    method samecase(Cool:D: Cool $pattern)

    Coerces the invocant (or in sub form, the first argument) to Str, and returns a copy of $string with case information for each individual character changed according to $pattern. (The pattern string can contain three types of characters, i.e. uppercase, lowercase and caseless. For a given character in $pattern its case information determines the case of the corresponding character in the result.) If $string is longer than $pattern, the case information from the last character of $pattern is applied to the remaining characters of $string.

    say "perL 6".samecase("A__a__"); # OUTPUT: «Perl 6␤» 
    say "pERL 6".samecase("Ab");     # OUTPUT: «Perl 6␤» 

    (Cool) method uniprop

    Defined as:

    multi sub uniprop(Str(Cool), |c)
    multi sub uniprop(Int:D $codeStringy:D $propname)
    multi sub uniprop(Str$codeStringy:D $propname)
    multi method uniprop(|c)

    Interprets the invocant as a Str, and returns the unicode property of the first character. If no property is specified returns the General Category. Returns a Bool for Boolean properties.

    say 'a'.uniprop;               # OUTPUT: «Ll␤» 
    say '1'.uniprop;               # OUTPUT: «Nd␤» 
    say 'a'.uniprop('Alphabetic'); # OUTPUT: «True␤» 
    say '1'.uniprop('Alphabetic'); # OUTPUT: «False␤» 

    (Cool) method uniprops

    Defined as:

    sub uniprops(Str:D $strStringy:D $propname = "General_Category")

    Interprets the invocant as a Str, and returns the unicode property for each character as a Seq. If no property is specified returns the General Category. Returns a Bool for Boolean properties. Similar to uniprop

    (Cool) method uniname

    Defined as:

    sub uniname(Str(Cool--> Str)
    method uniname(--> Str)

    Interprets the invocant / first argument as a Str, and returns the Unicode codepoint name of the first codepoint of the first character. See uninames for a routine that works with multiple codepoints.

    # Camelia in Unicode 
    say »ö«.uniname;
    say "Ḍ̇".uniname# Note, doesn't show "COMBINING DOT ABOVE" 
    # Find the char with the longest Unicode name. 
    say (0..0x1FFFF).sort(*.uniname.chars)[*-1].chr.uniname;

    (Cool) method uninames

    Defined as:

    sub uninames(Str:D)
    method uninames()

    Returns of a Seq of Unicode names for the all the codepoints in the Str provided.

    say »ö«.uninames.perl;

    Note this example, which gets a Seq where each element is a Seq of all the codepoints in that character.

    say "Ḍ̇'oh".comb>>.uninames.perl;

    (Cool) method unimatch

    Defined as:

    multi sub unimatch(Str:D $str|c)
    multi unimatch(Int:D $codeStringy:D $pvalnameStringy:D $propname = $pvalname)

    Checks if the given integer codepoint or the first letter of the string given have a unicode property equal to the value you give. If you supply the Unicode property to be checked it will only return True if that property matches the given value.

    say unimatch 'A''Latin';           # OUTPUT: «True␤» 
    say unimatch 'A''Latin''Script'# OUTPUT: «True␤» 
    say unimatch 'A''Ll';              # OUTPUT: «True␤» 

    (Cool) routine chop

    Defined as:

    sub chop(Str(Cool))
    method chop()

    Coerces the invocant (or in sub form, its argument) to Str, and returns it with the last character removed.

    say 'perl'.chop;                        # OUTPUT: «per␤» 

    (Cool) routine chomp

    Defined as:

    sub chomp(Str(Cool))
    method chomp()

    Coerces the invocant (or in sub form, its argument) to Str, and returns it with the last character removed, if it is a logical newline.

    say 'ab'.chomp.chars;                   # OUTPUT: «2␤» 
    say "a\n".chomp.chars;                  # OUTPUT: «1␤» 

    (Cool) routine substr

    Defined as:

    sub substr(Str(Cool$str$from$chars?)
    method substr($from$chars?)

    Coerces the invocant (or in the sub form, the first argument) to Str, and returns the string starting from offset $from. If $chars is supplied, at most $chars characters are returned.

    say 'zenith'.substr(2);         # OUTPUT: «nith␤» 
    say 'zenith'.substr(03);      # OUTPUT: «zen␤» 
    # works on non-strings too: 
    say 20151224.substr(6);         # OUTPUT: «24␤» 
    # sub form: 
    say substr "zenith"03;      # OUTPUT: «zen␤» 

    If the $from parameter is a Callable, it is called with the number of chars in the string as argument. This allows easy indexing relative to the end:

    say 20151224.substr(*-2);       # OUTPUT: «24␤» 

    (Cool) routine ords

    Defined as:

    sub ords(Str(Cool$str)
    method ords()

    Coerces the invocant (or in the sub form, the first argument) to Str, and returns a list of Unicode codepoints for each character.

    say "Camelia".ords;              # OUTPUT: «67 97 109 101 108 105 97␤» 
    say ords 10;                     # OUTPUT: «49 48␤» 

    This is the list-returning version of ord. The inverse operation in chrs.

    (Cool) routine chrs

    Defined as:

    sub chrs(*@codepoints --> Str:D)
    method chrs()

    Coerces the invocant (or in the sub form, the argument list) to a list of integers, and returns the string created by interpreting each integer as a Unicode codepoint, and joining the characters.

    say <67 97 109 101 108 105 97>.chrs;   # OUTPUT: «Camelia␤» 

    This is the list-input version of chr. The inverse operation is ords.

    (Cool) routine split

    Defined as:

    multi sub    split(  Str:D $delimiterStr(Cool$input$limit = Inf:$k:$v:$kv:$p:$skip-empty)
    multi sub    split(Regex:D $delimiterStr(Cool$input$limit = Inf:$k:$v:$kv:$p:$skip-empty)
    multi sub    split(@delimitersStr(Cool$input$limit = Inf:$k:$v:$kv:$p:$skip-empty)
    multi method split(  Str:D $delimiter$limit = Inf:$k:$v:$kv:$p:$skip-empty)
    multi method split(Regex:D $delimiter$limit = Inf:$k:$v:$kv:$p:$skip-empty)
    multi method split(@delimiters$limit = Inf:$k:$v:$kv:$p:$skip-empty)

    Coerces the invocant (or in the sub form, the second argument) to Str, and splits it into pieces based on delimiters found in the string.

    If $delimiter is a string, it is searched for literally and not treated as a regex. You can also provide multiple delimiters by specifying them as a list; mixing Cool and Regex objects is OK.

    say split(';'"a;b;c").perl;               # OUTPUT: «("a", "b", "c")␤» 
    say split(';'"a;b;c"2).perl;            # OUTPUT: «("a", "b;c").Seq␤» 
    say split(';'"a;b;c,d").perl;             # OUTPUT: «("a", "b", "c,d")␤» 
    say split(/\;/"a;b;c,d").perl;            # OUTPUT: «("a", "b", "c,d")␤» 
    say split(/<[;,]>/"a;b;c,d").perl;        # OUTPUT: «("a", "b", "c", "d")␤» 
    say split(['a', /b+/4], '1a2bb345').perl# OUTPUT: «("1", "2", "3", "5")␤» 

    By default, split omits the matches, and returns a list of only those parts of the string that did not match. Specifying one of the :k, :v, :kv, :p adverbs changes that. Think of the matches as a list that is interleaved with the non-matching parts.

    The :v interleaves the values of that list, which will be either Match objects, if a Regex was used as a matcher in the split, or Str objects, if a Cool was used as matcher. If multiple delimiters are specified, Match objects will be generated for all of them, unless all of the delimiters are Cool.

    say 'abc'.split(/b/:v);               # OUTPUT: «(a 「b」 c)␤» 
    say 'abc'.split('b':v);               # OUTPUT: «(a b c)␤» 

    :k interleaves the keys, that is, the indexes:

    say 'abc'.split(/b/:k);               # OUTPUT: «(a 0 c)␤» 

    :kv adds both indexes and matches:

    say 'abc'.split(/b/:kv);               # OUTPUT: «(a 0 「b」 c)␤» 

    and :p adds them as Pairs, using the same types for values as :v does:

    say 'abc'.split(/b/:p);               # OUTPUT: «(a 0 => 「b」 c)␤» 
    say 'abc'.split('b':p);               # OUTPUT: «(a 0 => b c)␤» 

    You can only use one of the :k, :v, :kv, :p adverbs in a single call to split.

    Note that empty chunks are not removed from the result list. For that behavior, use the `:skip-empty` named argument:

    say ("f,,b,c,d".split: /","/             ).perl;  # OUTPUT: «("f", "", "b", "c", "d")␤» 
    say ("f,,b,c,d".split: /","/:skip-empty).perl;  # OUTPUT: «("f", "b", "c", "d")␤» 

    See also: comb.

    (Cool) routine lines

    Defined as:

    sub lines(Str(Cool))
    method lines()

    Coerces the invocant (and in sub form, the argument) to Str, decomposes it into lines (with the newline characters stripped), and returns the list of lines.

    say lines("a\nb\n").join('|');          # OUTPUT: «a|b␤» 
    say "some\nmore\nlines".lines.elems;    # OUTPUT: «3␤» 

    This method can be used as part of an IO::Path to process a file line-by-line, since IO::Path objects inherit from Cool, e.g.:

    for 'huge-csv'.IO.lines -> $line {
        # Do something with $line 
    # or if you'll be processing later 
    my @lines = 'huge-csv'.IO.lines;

    Without any arguments, sub lines operates on $*ARGFILES, which defaults to $*IN in the absence of any filenames.

    To modify values in place use is copy to force a writable container.

    for $*IN.lines -> $_ is copy { s/(\w+)/{$0 ~ $0}/.say }

    (Cool) method words

    Defined as:

    method words(Int() $limit)

    Coerces the invocant to Str, and returns a list of words that make up the string (and if $limit is supplied, only the first $limit words).

    say 'The quick brown fox'.words.join('|');      # OUTPUT: «The|quick|brown|fox␤» 
    say 'The quick brown fox'.words(2).join('|');   # OUTPUT: «The|quick␤» 

    Only whitespace counts as word boundaries

    say "isn't, can't".words.join('|');             # OUTPUT: «isn't,|can't␤» 

    (Cool) routine comb

    Defined as:

    multi sub comb(Regex $matcherStr(Cool$input$limit = * --> Seq)
    multi method comb(Regex $matcher$limit = * --> Seq)

    Returns all (or if supplied, at most $limit) matches of the invocant (method form) or the second argument (sub form) against the Regex as a list of strings.

    say "6 or 12".comb(/\d+/).join("");           # OUTPUT: «6, 12␤» 

    (Cool) method contains

    multi method contains(Cool:D: Str(Cool$needleCool $start? --> Bool:D)

    Returns True if the invocant contains the $needle at any position within the string. If $start is provided skip as many characters.

    say "Hello, World".contains('hello');      # OUTPUT: «False␤» 
    say "Hello, World".contains(',');          # OUTPUT: «True␤» 

    (Cool) routine index

    Defined as:

    multi sub    index(Str(Cool$sStr:D $needleInt(Cool$startpos = 0 --> Int)
    multi method index(Str(Cool$needleInt(Cool$startpos = 0 --> Int)

    Coerces the first two arguments (in method form, also counting the invocant) to Str, and searches for $needle in the string starting from $startpos. It returns the offset into the string where $needle was found, and an undefined value if it was not found.

    See the documentation in type Str for examples.

    (Cool) routine rindex

    Defined as:

    multi sub    rindex(Str(Cool$haystackStr(Cool$needleInt(Cool$startpos = $haystack.chars)
    multi method rindex(Str(Cool$haystack: Str(Cool$needleInt(Cool$startpos = $haystack.chars)

    Coerces the first two arguments (including the invocant in method form) to Str and $startpos to Int, and returns the last position of $needle in $haystack not after $startpos. Returns an undefined value if $needle wasn't found.

    See the documentation in type Str for examples.

    (Cool) routine match

    Defined as:

    multi method match(Cool:D: $target*%adverbs)

    Coerces the invocant to Str and calls the method match on it.

    (Cool) method fmt

    Defined as:

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

    Uses $format to return a formatted representation of the invocant.

    For more information about formats strings, see sprintf.

    say 11.fmt('This Int equals %03d');               # OUTPUT: «This Int equals 011␤» 
    say '16'.fmt('Hexadecimal %x');                   # OUTPUT: «Hexadecimal 10␤» 

    (Cool) routine roots

    Defined as:

    multi sub roots(Numeric(Cool$xInt(Cool$n)
    multi method roots(Int(Cool$n)

    Coerces the first argument (and in method form, the invocant) to Numeric and the second ($n) to Int, and produces a list of $n Complex $n-roots, which means numbers that, raised to the $nth power, approximately produce the original number.

    For example

    my $original = 16;
    my @roots = $original.roots(4);
    say @roots;
    for @roots -> $r {
        say abs($r ** 4 - $original);

    produces this output:

    2+0i 1.22464679914735e-16+2i -2+2.44929359829471e-16i -3.67394039744206e-16-2i

    (Cool) method IO

    Defined as:

    method IO(--> IO::Path:D)

    Coerces the invocant to IO::Path.

    .say for '.'.IO.dir;        # gives a directory listing 

    (Cool) routine EVAL

    Defined as:

    sub EVAL(Cool $code:$lang = { ... })

    Coerces the invocant to Str.

    This works as-is with a literal string parameter. More complex input, such as a variable or string with embedded code, is illegal by default. This can be overridden in any of several ways:

    use MONKEY;  # shortcut that turns on all MONKEY pragmas 
    use Test;
    # any of the above allows: 
    EVAL "say { 5 + 5 }";   # OUTPUT: «10␤» 

    Symbols in the current lexical scope are visible to code in an EVAL.

    my $answer = 42;
    EVAL 'say $answer;';    # OUTPUT: «42␤» 

    However, since the set of symbols in a lexical scope is immutable after compile time, an EVAL can never introduce symbols into the surrounding scope.

    EVAL 'my $lives = 9'say $lives;   # error, $lives not declared 

    Furthermore, the EVAL is evaluated in the current package:

    module M {
        EVAL 'our $answer = 42'
    say $M::answer;         # OUTPUT: «42␤» 

    And also the current language, meaning any added syntax is available:

    sub infix:<mean>(*@ais assoc<list> {
        @a.sum / @a.elems
    EVAL 'say 2 mean 6 mean 4';     # OUTPUT: «4␤» 

    An EVAL statement evaluates to the result of the last statement:

    sub infix:<mean>(*@ais assoc<list> {
        @a.sum / @a.elems
    say EVAL 'say 1; 2 mean 6 mean 4';         # OUTPUT: «1␤4␤» 

    EVAL is also a gateway for executing code in other languages:

    EVAL "use v5.20; say 'Hello from perl5!'":lang<Perl5>;

    (Cool) routine EVALFILE

    Defined as:

    sub EVALFILE(Cool $filename:$lang = { ... })

    Slurps the specified file and evaluates it. Behaves the same way as EVAL with regard to both scoping and the $lang parameter. Evaluates to the value produced by the final statement in the file.

    EVALFILE "foo.p6";

    Routines supplied by class Any

    Array inherits from class Any, which provides the following methods:

    (Any) method ACCEPTS

    Defined as:

    multi method ACCEPTS(Any:D: Mu $other)



    Returns True if $other === self (i.e. it checks object identity).

    Many built-in types override this for more specific comparisons

    (Any) method any

    Defined as:

    method any(--> Junction:D)

    Interprets the invocant as a list and creates an any-Junction from it.

    say so 2 == <1 2 3>.any;        # OUTPUT: «True␤» 
    say so 5 == <1 2 3>.any;        # OUTPUT: «False␤» 

    (Any) method all

    Defined as:

    method all(--> Junction:D)

    Interprets the invocant as a list and creates an all-Junction from it.

    say so 1 < <2 3 4>.all;         # OUTPUT: «True␤» 
    say so 3 < <2 3 4>.all;         # OUTPUT: «False␤» 

    (Any) method one

    Defined as:

    method one(--> Junction:D)

    Interprets the invocant as a list and creates a one-Junction from it.

    say so 1 == (123).one;      # OUTPUT: «True␤» 
    say so 1 == (121).one;      # OUTPUT: «False␤» 

    (Any) method none

    Defined as:

    method none(--> Junction:D)

    Interprets the invocant as a list and creates a none-Junction from it.

    say so 1 == (123).none;     # OUTPUT: «False␤» 
    say so 4 == (123).none;     # OUTPUT: «True␤» 

    (Any) method list

    Defined as:

    method list(--> List:D)

    Interprets the invocant as a list, and returns that List.

    say 42.list.^name;           # OUTPUT: «List␤» 
    say 42.list.elems;           # OUTPUT: «1␤» 

    (Any) method push

    Defined as:

    method push(|values --> Positional:D)

    The method push is defined for undefined invocants and allows for autovivifying undefined to an empty Array, unless the undefined value implements Positional already. The argument provided will then be pushed into the newly created Array.

    my %h;
    dd %h<a>;      # Any (and therefore undefined) 
    %h<a>.push(1); # .push on Any 
    dd %h;         # «Hash %h = {:a($[1])}␤» # please note the Array 

    (Any) routine reverse

    Defined as:

    multi sub    reverse(*@list  --> Seq:D)
    multi method reverse(List:D: --> 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.


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

    (Any) method sort

    Defined as:

    multi method sort()
    multi method sort(&by)

    Sorts iterables with infix:<cmp> or given code object and returns a new List. Optionally, takes a Callable as a positional parameter, specifying how to sort.


    say <b c a>.sort;                           # OUTPUT: «(a b c)␤» 
    say 'bca'.comb.sort.join;                   # OUTPUT: «abc␤» 
    say 'bca'.comb.sort({$^b cmp $^a}).join;    # OUTPUT: «cba␤» 
    say '231'.comb.sort(&infix:«<=>»).join;     # OUTPUT: «123␤» 

    (Any) method map

    Defined as:

    multi method map(\SELF: &block;; :$label:$item)
    multi method map(HyperIterable:D: &block;; :$label)

    map will iterate over the invocant and apply the number of positional parameters of the code object from the invocant per call. The returned values of the code object will become elements of the returned Seq.

    The :$label and :$item are useful only internally, since for loops get converted to maps. The :$label takes an existing Label to label the .map's loop with and :$item controls whether the iteration will occur over (SELF,) (if :$item is set) or SELF.

    (Any) method deepmap

    Defined as:

    method deepmap(&block --> Listis nodal

    deepmap will apply &block to each element and return a new List with the return values of &block, unless the element does the Iterable role. For those elements deepmap will descend recursively into the sublist.

    dd [[1,2,3],[[4,5],6,7]].deepmap(*+1);
    # OUTPUT: «[[2, 3, 4], [[5, 6], 7, 8]]␤» 

    (Any) method duckmap

    Defined as:

    method duckmap(&blockis rw is nodal

    duckmap will apply &block on each element and return a new list with defined return values of the block. For undefined return values, duckmap will try to descend into the element if that element implements Iterable.

    <a b c d e f g>.duckmap(-> $_ where <c d e>.any { .uc }).say;
    # OUTPUT: «(a b C D E f g)␤» 
    (('d''e'), 'f').duckmap(-> $_ where <e f>.any { .uc }).say;
    # OUTPUT: «((d E) F)␤» 

    (Any) method nodemap

    Defined as:

    method nodemap(&block --> Listis nodal

    nodemap will apply &block to each element and return a new List with the return values of &block. In contrast to deepmap it will not descend recursively into sublists if it finds elements which does the Iterable role.

    say [[1,2,3], [[4,5],6,7], 7].nodemap(*+1);
    # OUTPUT: «(4, 4, 8)␤» 
    say [[23], [4, [56]]]».nodemap(*+1)
    # OUTPUT: «((3 4) (5 3))␤» 

    The examples above would have produced the exact same results if we had used map instead of nodemap. The difference between the two lies in the fact that map flattens out slips while nodemap doesn't.

    say [[2,3], [[4,5],6,7], 7].nodemap({.elems == 1 ?? $_ !! slip});
    # OUTPUT: «(() () 7)␤» 
    say [[2,3], [[4,5],6,7], 7].map({.elems == 1 ?? $_ !! slip});
    # OUTPUT: «(7)␤» 

    (Any) method flat

    Defined as:

    method flat(--> Seq:Dis nodal

    Interprets the invocant as a list, flattens non-containerized Iterables into a flat list, and returns that list. Keep in mind Map and Hash types are Iterable and so will be flattened into lists of pairs.

    say ((12), (3), %(:42a));      # OUTPUT: «((1 2) 3 {a => 42})␤» 
    say ((12), (3), %(:42a)).flat# OUTPUT: «(1 2 3 a => 42)␤» 

    Note that Arrays containerize their elements by default, and so flat will not flatten them. You can use hyper method call to call .List method on all the inner Iterables and so de-containerize them, so that flat can flatten them:

    say [[123], [(45), 67]]      .flat# OUTPUT: «([1 2 3] [(4 5) 6 7])␤» 
    say [[123], [(45), 67]]».List.flat# OUTPUT: «(1 2 3 4 5 6 7)␤» 

    For more fine-tuned options, see deepmap, duckmap, and signature destructuring

    (Any) method eager

    Defined as:

    method eager(--> Seq:Dis nodal

    Interprets the invocant as a list, evaluates it eagerly, and returns that list.

    say (1..10).eager;              # OUTPUT: «(1 2 3 4 5 6 7 8 9 10)␤» 

    (Any) method elems

    Defined as:

    method elems(--> Int:Dis nodal

    Interprets the invocant as a list, and returns the number of elements in the list.

    say 42.elems;                   # OUTPUT: «1␤» 
    say <a b c>.elems;              # OUTPUT: «3␤» 

    (Any) method end

    method end(--> Any:Dis nodal

    Interprets the invocant as a list, and returns the last index of that list.

    say 6.end;                      # OUTPUT: «0␤» 
    say <a b c>.end;                # OUTPUT: «2␤» 

    (Any) method pairup

    Defined as:

    method pairup(--> Seq:Dis nodal

    Interprets the invocant as a list, and constructs a list of pairs from it, in the same way that assignment to a Hash does. That is, it takes two consecutive elements and constructs a pair from them, unless the item in the key position already is a pair (in which case the pair is passed is passed through, and the next list item, if any, is considered to be a key again).

    say (=> 1'b''c').pairup.perl;     # OUTPUT: «(:a(1), :b("c")).Seq␤» 

    (Any) sub exit

    Defined as:

    sub exit(Int() $status = 0)

    Exits the current process with return code $status.

    (Any) sub item

    Defined as:

    proto sub item(|) is pure
    multi sub item(\x)
    multi sub item(|c)
    multi sub item(Mu $a)

    Forces given object to be evaluated in item context and returns the value of it.

    say item([1,2,3]).perl;              # OUTPUT: «$[1, 2, 3]␤» 
    say item({ apple => 10 }).perl;      # OUTPUT: «${:apple(10)}␤» 
    say item("abc").perl;                # OUTPUT: «"abc"␤» 

    You can also use $ as item contextualizer.

    say $[1,2,3].perl;                   # OUTPUT: «$[1, 2, 3]␤» 
    say $("abc").perl;                   # OUTPUT: «"abc"␤» 

    (Any) method Array

    Defined as:

    method Array(--> Array:Dis nodal

    Coerce the invocant to Array.

    (Any) method List

    Defined as:

    method List(--> List:Dis nodal

    Coerce the invocant to List.

    (Any) method Hash

    Defined as:

    method Hash(--> Hash:Dis nodal

    Coerce the invocant to Hash.

    (Any) method hash

    Defined as:

    method hash(--> Hash:Dis nodal

    Coerce the invocant to Hash.

    (Any) method Slip

    Defined as:

    method Slip(--> Slip:Dis nodal

    Coerce the invocant to Slip.

    (Any) method Map

    Defined as:

    method Map(--> Map:Dis nodal

    Coerce the invocant to Map.

    (Any) method Bag

    Defined as:

    method Bag(--> Bag:Dis nodal

    Coerce the invocant to Bag, whereby Positionals are treated as lists of values.

    (Any) method BagHash

    Defined as:

    method BagHash(--> BagHash:Dis nodal

    Coerce the invocant to BagHash, whereby Positionals are treated as lists of values.

    (Any) method Set

    Defined as:

    method Set(--> Set:Dis nodal

    Coerce the invocant to Set, whereby Positionals are treated as lists of values.

    (Any) method SetHash

    Defined as:

    method SetHash(--> SetHash:Dis nodal

    Coerce the invocant to SetHash, whereby Positionals are treated as lists of values.

    (Any) method Mix

    Defined as:

    method Mix(--> Mix:Dis nodal

    Coerce the invocant to Mix, whereby Positionals are treated as lists of values.

    (Any) method MixHash

    Defined as:

    method MixHash(--> MixHash:Dis nodal

    Coerce the invocant to MixHash, whereby Positionals are treated as lists of values.

    (Any) method Supply

    Defined as:

    method Supply(--> Supply:Dis nodal

    Coerce the invocant first to a List and then to a Supply.

    (Any) method min

    Defined As:

    multi method min(--> Any:D)
    multi method min(&by --> Any:D)

    Coerces to Iterable and returns the numerically smallest element. If a Callable positional argument is provided it is called with each element and its smallest return values is returned.

    (Any) method max

    Defined As:

    multi method max(--> Any:D)
    multi method max(&by --> Any:D)

    Coerces to Iterable and returns the numerically biggest element. If a Callable positional argument is provided it is called with each element and its biggest return values is returned.

    (Any) method minmax

    Defined As:

    multi method minmax(--> List:D)
    multi method minmax(&by --> List:D)

    Returns a list containing the smallest and the biggest element. If a Callable positional argument is provided each element is filtered and then numerically compared.

    (Any) method minpairs

    Defined As:

    multi method minpairs(Any:D: --> Seq:D)

    Calls .pairs and returns a Seq with all of the Pairs with minimum values, as judged by the cmp operator:

    <a b c a b c>.minpairs.perl.put# OUTPUT: «(0 => "a", 3 => "a").Seq␤» 
    %(:42a, :75b).minpairs.perl.put# OUTPUT: «(:a(42),).Seq␤» 

    (Any) method maxpairs

    Defined As:

    multi method maxpairs(Any:D: --> Seq:D)

    Calls .pairs and returns a Seq with all of the Pairs with maximum values, as judged by the cmp operator:

    <a b c a b c>.maxpairs.perl.put# OUTPUT: «(2 => "c", 5 => "c").Seq␤» 
    %(:42a, :75b).maxpairs.perl.put# OUTPUT: «(:b(75),).Seq␤» 

    (Any) method sum

    Defined As:

        method sum(--> TODO)


    (Any) method keys

    Defined As:

        method keys(--> TODO)


    (Any) method flatmap

    Defined As:

        method flatmap(--> TODO)


    (Any) method roll

    Defined As:

        method roll(--> TODO)


    (Any) method pick

    Defined As:

        method pick(--> TODO)


    (Any) method head

    Defined As:

        method head(--> TODO)


    (Any) method tail

    Defined As:

        method tail(--> TODO)


    (Any) method skip

    Defined As:

        method skip(--> TODO)


    (Any) method prepend

    Defined As:

        method prepend(--> TODO)


    (Any) method unshift

    Defined As:

        method unshift(--> TODO)


    (Any) method first

    Defined As:

        method first(--> TODO)


    (Any) method unique

    Defined As:

        method unique

    Treats the Any as a 1-item list and uses List.unique on it.

    (Any) method repeated

    Defined As:

        method repeated(--> TODO)


    (Any) method squish

    Defined As:

        method squish(--> TODO)


    (Any) method reduce

    Defined As:

        method reduce(--> TODO)


    (Any) method permutations

    Defined As:

        method permutations(--> TODO)


    (Any) method categorize

    Defined As:

        method categorize(--> TODO)


    (Any) method classify

    Defined As:

        method classify(--> TODO)


    (Any) method produce

    Defined As:

        method produce(--> TODO)


    (Any) method rotor

    Defined As:

        method rotor(--> TODO)


    (Any) method pairs

    Defined As:

        method pairs(--> TODO)


    (Any) method antipairs

    Defined As:

        method antipairs(--> TODO)


    (Any) method kv

    Defined As:

        method kv(--> TODO)


    (Any) method tree

    Defined As:

        method tree(--> TODO)


    (Any) method nl-out

    Defined As:

        method nl-out(--> TODO)


    (Any) method invert

    Defined As:

        method invert(--> TODO)


    (Any) method combinations

    Defined As:

        method combinations(--> TODO)


    (Any) method print-nl

    Defined As:

        method print-nl(--> TODO)


    (Any) method iterator

    Defined As:

        method iterator(--> TODO)


    (Any) method grep

    Defined As:

        method grep(--> TODO)


    (Any) method match

    Defined As:

        method match(--> TODO)


    (Any) method append

    Defined As:

        method append(--> TODO)


    (Any) method join

    Defined As:

        method join(--> TODO)


    (Any) method values

    Defined As:

        method values(--> TODO)


    (Any) method collate

    Defined As:

        method collate(--> TODO)


    (Any) method batch

    Defined As:

        method batch(--> TODO)


    (Any) method cache

    Defined As:

        method cache(--> TODO)


    Routines supplied by class Mu

    Array inherits from class Mu, which provides the following methods:

    (Mu) routine defined

    multi sub    defined(Mu --> Bool:D)
    multi method defined(   --> Bool:D)

    Returns False on the type object, and True otherwise.

    say Int.defined;                # OUTPUT: «False␤» 
    say 42.defined;                 # OUTPUT: «True␤» 

    Very few types (like Failure) override defined to return False even for instances:

    sub fails() { fail 'oh noe' };
    say fails().defined;            # OUTPUT: «False␤» 

    (Mu) routine isa

    multi method isa(Mu $type     --> Bool:D)
    multi method isa(Str:D $type  --> Bool:D)

    Returns True if the invocant is an instance of class $type, a subset type or a derived class (through inheritance) of $type.

    my $i = 17;
    say $i.isa("Int");   # OUTPUT: «True␤» 
    say $i.isa(Any);     # OUTPUT: «True␤» 

    A more idiomatic way to do this is to use the smartmatch operator ~~ instead.

    my $s = "String";
    say $s ~~ Str;       # OUTPUT: «True␤» 

    (Mu) routine does

    method does(Mu $type --> Bool:D)

    Returns True if and only if the invocant conforms to type $type.

    my $d ='2016-06-03');
    say $d.does(Dateish);             # True    (Date does role Dateish) 
    say $d.does(Any);                 # True    (Date is a subclass of Any) 
    say $d.does(DateTime);            # False   (Date is not a subclass of DateTime) 

    Using the smart match operator ~~ is a more idiomatic alternative.

    my $d ='2016-06-03');
    say $d ~~ Dateish;                # OUTPUT: «True␤» 
    say $d ~~ Any;                    # OUTPUT: «True␤» 
    say $d ~~ DateTime;               # OUTPUT: «False␤» 

    (Mu) routine Bool

    multi sub    Bool(Mu --> Bool:D)
    multi method Bool(   --> Bool:D)

    Returns False on the type object, and True otherwise.

    Many built-in types override this to be False for empty collections, the empty string or numerical zeros

    say Mu.Bool;                    # OUTPUT: «False␤» 
    say;                # OUTPUT: «True␤» 
    say [123].Bool;             # OUTPUT: «True␤» 
    say [].Bool;                    # OUTPUT: «False␤» 
    say { 'hash' => 'full' }.Bool;  # OUTPUT: «True␤» 
    say {}.Bool;                    # OUTPUT: «False␤» 
    say "".Bool;                    # OUTPUT: «False␤» 
    say 0.Bool;                     # OUTPUT: «False␤» 
    say 1.Bool;                     # OUTPUT: «True␤» 
    say "0".Bool;                   # OUTPUT: «True␤» 

    (Mu) method Capture

    Defined as:

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

    Returns a Capture with named arguments corresponding to invocant's public attributes:

    class Foo {
        has $.foo = 42;
        has $.bar = 70;
        method bar { 'something else' }
    }.new.Capture.say# OUTPUT: «\(:bar("something else"), :foo(42))␤» 

    (Mu) method Str

    multi method Str(--> Str)

    Returns a string representation of the invocant, intended to be machine readable. Method Str warns on type objects, and produces the empty string.

    say Mu.Str;                     # Use of uninitialized value of type Mu in string context. 

    (Mu) routine gist

    multi sub    gist(+args --> Str)
    multi method gist(   --> Str)

    Returns a string representation of the invocant, optimized for fast recognition by humans. As such lists will be truncated at 100 elements. Use .perl to get all elements.

    The default gist method in Mu re-dispatches to the perl method for defined invocants, and returns the type name in parenthesis for type object invocants. Many built-in classes override the case of instances to something more specific that may truncate output.

    gist is the method that say calls implicitly, for non-Str types, so say $something and say $something.gist generally produce the same output.

    say Mu.gist;        # OUTPUT: «(Mu)␤» 
    say;    # OUTPUT: «␤» 

    (Mu) routine perl

    multi sub    perl(Mu --> Str)
    multi method perl(   --> Str)

    Returns a Perlish representation of the object (i.e., can usually be re-evaluated with EVAL to regenerate the object). The exact output of perl is implementation specific, since there are generally many ways to write a Perl expression that produces a particular value

    (Mu) method item

    method item(Mu \item:is raw

    Forces the invocant to be evaluated in item context and returns the value of it.

    say [1,2,3].item.perl;         # OUTPUT: «$[1, 2, 3]␤» 
    say { apple => 10 }.item.perl# OUTPUT: «${:apple(10)}␤» 
    say "abc".item.perl;           # OUTPUT: «"abc"␤» 

    (Mu) method self

    method self(--> Mu)

    Returns the object it is called on.

    (Mu) method clone

    method clone(*%twiddles)

    Creates a shallow clone of the invocant. Alternative values for public attributes can be provided via named arguments with names matching the attributes' names.

    class Point2D {
        has ($.x$.y);
        multi method gist(Point2D:D:{
    my $p = => 2=> 3);
    say $p;                     # OUTPUT: «Point(2, 3)␤» 
    say $p.clone(=> -5);      # OUTPUT: «Point(2, -5)␤» 

    (Mu) method new

    multi method new(*%attrinit)

    Default method for constructing (create + initialize) new objects of a class. This method expects only named arguments which are then used to initialize attributes with accessors of the same name.

    Classes may provide their own new method to override this default.

    new triggers an object construction mechanism that calls submethods named BUILD in each class of an inheritance hierarchy, if they exist. See the documentation on object construction for more information.

    (Mu) method bless

    method bless(*%attrinit --> Mu:D)

    Lower-level object construction method than new.

    Creates a new object of the same type as the invocant, uses the named arguments to initialize attributes, and returns the created object.

    You can use this method when writing custom constructors:

    class Point {
        has $.x;
        has $.y;
        multi method new($x$y{
    my $p =;

    (Though each time you write a custom constructor, remember that it makes subclassing harder).

    (Mu) method CREATE

    method CREATE(--> Mu:D)

    Allocates a new object of the same type as the invocant, without initializing any attributes.

    say Mu.CREATE.defined;  # OUTPUT: «True␤» 

    (Mu) method print

    multi method print(--> Bool:D)

    Prints value to $*OUT after stringification using .Str method without adding a newline at end.

    "abc\n".print;          # RESULT: «abc␤» 

    (Mu) method put

    multi method put(--> Bool:D)

    Prints value to $*OUT, adding a newline at end, and if necessary, stringifying non-Str object using the .Str method.

    "abc".put;              # RESULT: «abc␤» 

    (Mu) method say

    multi method say(--> Bool:D)

    Prints value to $*OUT after stringification using .gist method with newline at end. To produce machine readable output use .put.

    say 42;                 # OUTPUT: «42␤» 

    (Mu) method ACCEPTS

    multi method ACCEPTS(Mu:U: $other)

    ACCEPTS is the method that smart matching with the infix ~~ operator and given/when invokes on the right-hand side (the matcher).

    The Mu:U multi performs a type check. Returns True if $other conforms to the invocant (which is always a type object or failure).

    say 42 ~~ Mu;           # OUTPUT: «True␤» 
    say 42 ~~ Int;          # OUTPUT: «True␤» 
    say 42 ~~ Str;          # OUTPUT: «False␤» 

    Note that there is no multi for defined invocants; this is to allow autothreading of junctions, which happens as a fallback mechanism when no direct candidate is available to dispatch to.

    (Mu) method WHICH

    multi method WHICH(--> ObjAt:D)

    Returns an object of type ObjAt which uniquely identifies the object. Value types override this method which makes sure that two equivalent objects return the same return value from WHICH.

    say 42.WHICH eq 42.WHICH;       # OUTPUT: «True␤» 

    (Mu) method WHERE

    method WHERE(--> Int)

    Returns an Int representing the memory address of the object.

    (Mu) method WHY

    multi method WHY()

    Returns the attached Pod value. For instance,

    sub cast(Spell $s)
    #= Initiate a specified spell normally 
    #= (do not use for class 7 spells) 
    say &cast.WHY;


    Initiate a specified spell normally (do not use for class 7 spells)

    See the documentation specification for details about attaching Pod to variables, classes, functions, methods, etc.

    (Mu) trait is export

    multi sub trait_mod:<is>(Mu:U \type:$export!)

    Marks a type as being exported, that is, available to external users.

    my class SomeClass is export { }

    A user of a module or class automatically gets all the symbols imported that are marked as is export.

    See Exporting and Selective Importing Modules for more details.

    (Mu) method return

    method return()

    The method return will stop execution of a subroutine or method, run all relevant phasers and provide invocant as a return value to the caller. If a return type constraint is provided it will be checked unless the return value is Nil. A control exception is raised and can be caught with CONTROL.

    sub f { (1|2|3).return };
    dd f(); # OUTPUT: «any(1, 2, 3)␤» 

    (Mu) method return-rw

    Same as method return except that return-rw returns a writable container to the invocant (see more details here: return-rw).

    (Mu) method emit

    method emit()

    Emits the invocant into the enclosing supply or react block.

    react { whenever supply { .emit for "foo"42.5 } {
        say "received {.^name} ($_)";
    # OUTPUT: 
    # received Str (foo) 
    # received Int (42) 
    # received Rat (0.5) 

    (Mu) method take

    method take()

    Returns the invocant in the enclosing gather block.

    sub insert($sep+@list{
        gather for @list {
            FIRST .takenext;
            take slip $sep.item
    say insert ':', <a b c>;
    # OUTPUT: «(a : b : c)␤» 

    (Mu) routine take

    sub take(\item)

    Takes the given item and passes it to the enclosing gather block.

    #| randomly select numbers for lotto 
    my $num-selected-numbers = 6;
    my $max-lotto-numbers = 49;
    gather for ^$num-selected-numbers {
        take (1 .. $max-lotto-numbers).pick(1);
    }.say;    # six random values 

    (Mu) routine take-rw

    sub take-rw(\item)

    Returns the given item to the enclosing gather block, without introducing a new container.

    my @a = 1...3;
    sub f(@list){ gather for @list { take-rw $_ } };
    for f(@a{ $_++ };
    say @a;
    # OUTPUT: «[2 3 4]␤» 

    (Mu) method so

    method so()

    Returns a Bool value representing the logical non-negation of an expression. One can use this method similarly to the English sentence: "If that is so, then do this thing". For instance,

    my @args = <-a -e -b -v>;
    my $verbose-selected = any(@argseq '-v' | '-V';
    if $ {
        say "Verbose option detected in arguments";
    } # OUTPUT: «Verbose option detected in arguments␤» 

    (Mu) method not

    method not()

    Returns a Bool value representing the logical negation of an expression. Thus it is the opposite of so.

    my @args = <-a -e -b>;
    my $verbose-selected = any(@argseq '-v' | '-V';
    if $verbose-selected.not {
        say "Verbose option not present in arguments";
    } # OUTPUT: «Verbose option not present in arguments␤» 

    Since there is also a prefix version of not, the above code reads better like so:

    my @args = <-a -e -b>;
    my $verbose-selected = any(@argseq '-v' | '-V';
    if not $verbose-selected {
        say "Verbose option not present in arguments";
    } # OUTPUT: «Verbose option not present in arguments␤»