my class List does Iterable does Positional { }

List stores items sequentially and potentially lazily.

Indexes into lists and arrays start at 0 by default.

You can assign to list elements if they are containers. Use Arrays to have every value of the list stored in a container.

List implements Positional and as such provides support for subscripts.

Items, flattening and sigils

In Perl 6, assigning a List to a scalar variable does not lose information. The difference is that iteration generally treats a list (or any other list-like object, like a Seq or an Array) inside a scalar as a single element.

my $s = (1, 2, 3);
for $s { }      # one iteration 
for $s.list { } # three iterations 
 
my $t = [1, 2, 3];
for $t { }      # one iteration 
for $t.list { } # three iterations 
 
my @a = 1, 2, 3;
for @a { }      # three iterations 
for @a.item { } # one iteration

This operation is called itemization or putting in an item context. .item does the job for objects, as well as $( ... ) and, on array variables, $@a.

Lists generally don't interpolate (flatten) into other lists, except when they are in list context and the single argument to an operation such as append:

my $a = (1, 2, 3);
my $nested = ($a, $a);  # two elements 
 
my $flat = $nested.map({ .Slip });  # six elements, with explicit Slip 
 
my @b = <a b>;
@b.append: $a.list;     # The array variable @b has 5 elements, because 
                        # the list $a is the sole argument to append 
 
say @b.elems;           # OUTPUT: «5␤» 
 
my @c = <a b>;
@c.append: $a.list, 7;  # The array variable @c has 4 elements, because 
                        # the list $a wasn't the only argument and thus 
                        # wasn't flatten by the append operation 
 
say @c.elems;           # OUTPUT: «4␤» 
 
my @d = <a b>;
@d.append: $a;          # The array variable @d has 3 elements, because 
                        # $a is in  and as far as append is 
                        # concerned a single element 
 
say @d.elems;           # OUTPUT: «3␤»

The same flattening behavior applies all objects that do the Iterable role, notable hashes:

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

Slurpy parameters (*@a) flatten non-itemized sublists:

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

The empty list is created with (). Smartmatching against the empty list will check for the absence of elements.

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

Coercion to Bool also indicates if the List got any elements.

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

Methods

method ACCEPTS

Defined as:

multi method ACCEPTS(List:D: $topic)

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

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

In addition, returns False if either the invocant or $topic is a lazy Iterable, unless $topic is the same object as the invocant, in which case True is returned.

If $topic is not an Iterable, returns the invocant if the invocant has no elements or its first element is a Match object (this behavior powers m:g// smartmatch), or False otherwise.

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

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

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

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).^name;        # OUTPUT: «List␤» 
say (1,2,3,4).values.^name; # OUTPUT: «Seq␤»

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)

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)

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

routine invert

Defined as:

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

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

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

routine join

Defined as:

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

Treats the elements of the list as strings by calling .Str on each of them, interleaves them with $separator and concatenates everything into a single string. Note that you can omit the $separator if you use the method syntax.

Example:

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

The method form also allows you to omit the separator:

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

But it behaves slurpily, flattening all arguments after the first into a single list:

say join('|', 3, 'þ', 1+4i);    # OUTPUT: «3|þ|1+4i␤» 
say join ', ', <a b c>, 'd', 'e' , 'f'; # OUTPUT: «a, b, c, d, e, f␤»

In this case, the first list <a b c is slurped and flattened, unlike what happens when join is invoked as a method.

If one of the elements of the list happens to be a Junction, then join will also return a Junction with concatenation done as much as possible:

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

routine map

Defined as:

multi method map(Hash:D \hash)
multi method map(Iterable:D \iterable)
multi method map(|c)
multi method map(\SELF: █; :$label, :$item)
multi sub map(&code, +values)

Examples applied to lists are included here for the purpose of illustration.

For a list, it invokes &code for each element and gathers the return values in a sequence and returns it. This happens lazily, i.e. &code is only invoked when the return values are accessed.Examples:

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

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

((1, 2), <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 
};
s 
# RESULT: «hi»

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.

The use of flatmap is strongly discouraged. Instead of .flatmap( ), please use .map( ).flat as it is clear when the .flat is called and is not confusing like .flatmap.

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

## flatmap 
my @list = ('first1', ('second2', ('third3', 'third4'), 'second5'), 'first6');
say @list.flatmap({.reverse}).perl;
# OUTPUT «("first1", "second5", "third3", "third4", "second2", "first6").Seq␤» 
## map 
say @list.map({"$_ was a {.^name}"}).perl;
# OUTPUT «("first1 was a Str", "second2 third3 third4 second5 was a List", "first6 was a Str").Seq␤» 
## .map .flat has the same output as .flatmap 
say @list.map({.reverse}).flat.perl
# OUTPUT «("first1", "second5", "third3", "third4", "second2", "first6").Seq␤»

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 (1, 2, 3).gist;   # OUTPUT «(1 2 3)␤» 
put (1..∞).List.gist; # OUTPUT «(...)␤» 
 
put (1..200).List.gist;
# OUTPUT: 
# (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 
# 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 
# 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 
# 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 
# 96 97 98 99 100 ...) 

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 smartmatches. The elements are returned in the order in which they appear in the original list.

Examples:

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

Note that if you want to grep for elements that do not match, you can use a none-Junction:

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

Another option to grep for elements that do not match a regex is to use a block:

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

The reason the example above works is because a regex in boolean context applies itself to $_. In this case, ! boolifies the /<[aeiou]>/ regex and negates the result. Smartmatching against a Callable (in this case a Block) returns the value returned from that callable, so the boolified result of a regex is then used to decide whether the current value should be kept in the result of a grep.

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

Examples:

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

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 smartmatches against $matcher, returns Nil when no values match. The optional named parameter :end indicates that the search should be from the end of the list, rather than from the start.

Examples:

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

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.

Examples:

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

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.

method head

Defined as:

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

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

Examples:

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

method tail

Defined as:

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

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

Examples:

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

In the first case, $n is taking the shape of a WhateverCode to indicate the number of elements from the beginning that will be excluded. $n can be either a Callable, in which case it will be called with the value 0, or anything else that can be converted to a number, in which case it will use that as the number of elements in the output Seq.

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

routine categorize

Defined as:

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

These methods are directly inherited from Any; see Any.list for more examples.

This routine transforms a list of values into a hash representing the categorizations of those values according to $test, which is called once for every element in the list; each hash key represents one possible categorization for one or more of the incoming list values, and the corresponding hash value contains an array of those list values categorized by the $test, acting like a 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.

Example:

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

routine classify

Defined as:

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

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

Example:

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

It can also take :as as a named parameter, transforming the value before classifying it:

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

This code is classifying by number of characters, which is the expression that has been passed as $test parameter, but the :as block lowercases it before doing the transformation. The named parameter :into can also be used to classify into a newly defined variable:

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

We are declaring the scope of %words{Int} on the fly, with keys that are actually integers; it gets created with the result of the classification.

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

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

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

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

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

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; i.e. they are returned shuffled.

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

Examples:

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

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

Examples:

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

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.

my  \ll = (lazy 1..5).cache;
 
say ll[];     # OUTPUT: «(...)␤» 
say ll.eager  # OUTPUT: «(1 2 3 4 5)␤»

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.

Examples:

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

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.

Examples:

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

routine sort

Defined as:

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

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

If &custom-routine-to-use is provided, and it accepts two arguments, it is invoked for pairs of list elements, and should return Order::Less, Order::Same or Order::More.

If &custom-routine-to-use accepts only one argument, the list elements are sorted according to custom-routine-to-use($a) cmp custom-routine-to-use($b) . The return values of &custom-routine-to-use are cached, so that &custom-routine-to-use is only called once per list element.

Examples:

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

Additionally, if &custom-routine-to-use returns a List, elements will be sorted based upon multiple values with subsequent values in the List being used to break the tie if the comparison between the prior elements evaluate to Order::Same.

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

This sorting can be based on characteristics of a single element:

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

In this case, elements of the array are sorted in ascending order according first to the string length (.chars) and second to the actual alphabetical order .Str) if the length is exactly the same.

Any number of criteria can be used in this:

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

routine reduce

Defined as:

multi method reduce(Any:U: & --> Nil)
multi method reduce(Any:D: &with)
multi sub reduce (&with, +list)

The first form is obviously a no-op. The second form generates a single "combined" value from a list of arbitrarily many values, by iteratively applying a function which knows how to combine two values.

If @values contains just a single element, the operator is applied to that single element if possible; if not, it returns the element itself.

say [-] <10 5 3>; #OUTPUT: 2␤ 
say [-] 10;       #OUTPUT: 10␤

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 [ ] metaoperator 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

Please note also the use of reduce in sub form. 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, $b) is assoc<right> { "($a, $b)" }
say [foo] 1, 2, 3, 4; # OUTPUT: «(1, (2, (3, 4)))␤» 
 
sub infix:<bar>($a, $b) is assoc<left> { "($a, $b)" }
say [bar] 1, 2, 3, 4; # OUTPUT: «(((1, 2), 3), 4)␤»

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 metaoperator [\ ] 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)␤»

routine combinations

Defined as:

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

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

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

Above, there are three possible ways to combine the 2-items lists from the original list, which is what we receive in the output. See permutations if you want permutations instead of combinations.

With Range argument, we get both three 2-item combinations and one 3-item combination:

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

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

The subroutine form is equivalent to the method form called on the first argument ($from), with the exception that if $from is not an Iterable, it gets coerced to an Int and combinations are made from a Range constructed with 0..^$from instead:

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

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

routine permutations

Defined as:

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

Returns all possible permutations of a list as a Seq of lists:

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

permutations treats all elements as unique, thus (1, 1, 2).permutations returns a list of 6 elements, even though there are only three distinct permutations, due to first two elements being the same.

The subroutine form behaves the same as the method form, computing permutations from its first argument $from. If $from is not an Iterable, coerces $from to an Int and picks from a Range constructed with 0..^$from:

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

method rotor

Defined as:

method rotor(*@cycle, Bool() :$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(2, 3).join('|');           # OUTPUT: «a b|c d e|f g␤» 
say ('a'..'h').rotor(1 => 1, 3).join('|');      # OUTPUT: «a|c d e|f␤»

Combining multiple cycles and :partial also works:

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

See this blog post for more elaboration on rotor.

method batch

Defined As:

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

Returns a Seq of the elements in batches of :$elems or $batch, respectively. If the number of elements is not a multiple of $batch, the last batch may have less than $batch elements, similar to .rotor($batch, :partial).

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([1, 2, 3], [4, 5, 6], :with(&infix:<*>)).join(",");
# OUTPUT: «4,5,6,8,10,12,12,15,18␤»

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

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

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>, [1, 2, 3], (1, 2, 3), :with(&infix:<*>);
# OUTPUT: «1␤ 
# 8␤ 
# 27␤»

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

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

routine roundrobin

Defined as:

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

Builds a 'list of lists', returned as a sequence, from multiple input lists or other iterables. roundrobin returns an identical result to that of zip, except when the input lists are allowed to have an unequal number of elements.

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([1, 2], [2, 3], [3, 4]);
# 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([1, 2], [2, 3, 57, 77], [3, 4, 102]);
# 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.

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 (1, 3, pi).sum;       # OUTPUT: «7.14159265358979␤» 
say (1, "0xff").sum;      # OUTPUT: «256␤» 
say sum(0b1111, 5);       # OUTPUT: «20␤»

When being called on native integer arrays, it is also possible to specify a :wrap named parameter. This will add the values as native integers, wrapping around if they exceed the size of a native integer. If you are sure you will not exceed that value, or if you don't mind, using :wrap will make the calculation about 20x as fast.

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

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

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

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.

method sink

Defined as:

method sink(--> Nil) { }

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

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

method Set

In general, creates a set which has as members elements of the list.

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

However, there might be some unexpected changes in case the list includes non-scalar data structures. For instance, with Pairs:

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

The set will be composed of the keys of the Pair whose corresponding value is not 0, eliminating all the values. Please check the Set documentation for more examples and a more thorough explanation.

Operators

infix cmp

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

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

If the Lists are of different lengths, at most only $n comparisons will be made (where $n = @a.elems min @b.elems). If all of those comparisons evaluate to Order::Same, the final value is selected based upon which List is longer.

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

Type Graph

Expand above chart

Routines supplied by role Positional

List does role Positional, which provides the following routines:

(Positional) method of

method of()

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

(Positional) method elems

method elems()

Should return the number of available elements in the instantiated object.

(Positional) method AT-POS

method AT-POS(\position)

Should return the value / container at the given position.

(Positional) method EXISTS-POS

method EXISTS-POS(\position)

Should return a Bool indicating whether the given position actually has a value.

(Positional) method STORE

method STORE(\values, :$initialize)

This method should only be supplied if you want to support the:

my @a is Foo = 1,2,3;

syntax for binding your implementation of the Positional role.

Should accept the values to (re-)initialize the object with. The optional named parameter will contain a True value when the method is called on the object for the first time. Should return the invocant.

Routines supplied by role Iterable

List does role Iterable, which provides the following routines:

(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).lazy.is-lazy; # OUTPUT: «True␤»

(Iterable) method hyper

Defined as:

method hyper(Int(Cool) :$batch = 64, Int(Cool) :$degree = 4)

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].hyper.map({ $_ +1 }).list);

Use hyper in situations where it is OK to do the processing of items in parallel, and the output order should be kept relative to the input order. See race for situations where items are processed in parallel and the output order does not matter.

Options degree and batch

The degree option (short for "degree of parallelism") configures how many parallel workers should be started. To start 4 workers (e.g. to use at most 4 cores), pass :4degree to the hyper or race method. Note that in some cases, choosing a degree higher than the available CPU cores can make sense, for example I/O bound work or latency-heavy tasks like web crawling. For CPU-bound work, however, it makes no sense to pick a number higher than the CPU core count.

The batch size option configures the number of items sent to a given parallel worker at once. It allows for making a throughput/latency trade-off. If, for example, an operation is long-running per item, and you need the first results as soon as possible, set it to 1. That means every parallel worker gets 1 item to process at a time, and reports the result as soon as possible. In consequence, the overhead for inter-thread communication is maximized. In the other extreme, if you have 1000 items to process and 10 workers, and you give every worker a batch of 100 items, you will incur minimal overhead for dispatching the items, but you will only get the first results when 100 items are processed by the fastest worker (or, for hyper, when the worker getting the first batch returns.) Also, if not all items take the same amount of time to process, you might run into the situation where some workers are already done and sit around without being able to help with the remaining work. In situations where not all items take the same time to process, and you don't want too much inter-thread communication overhead, picking a number somewhere in the middle makes sense. Your aim might be to keep all workers about evenly busy to make best use of the resources available.

You can also check out this blog post on the semantics of hyper and race

(Iterable) method race

Defined as:

method race(Int(Cool) :$batch = 64, Int(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].race.map({ $_ +1 }).list);

Use race in situations where it is OK to do the processing of items in parallel, and the output order does not matter. See hyper for situations where you want items processed in parallel and the output order should be kept relative to the input order.

Blog post on the semantics of hyper and race

See hyper for an explanation of :$batch and :$degree.

Routines supplied by class Cool

List inherits from class Cool, which provides the following routines:

(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 EVAL

Defined as:

method EVAL(*%_)

It calls the subroutine form with the invocant as the first argument, $code, passing along named args, if any.

(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:

method atan2($y = 1e0)

Coerces self and argument to Numeric, using them to compute the two-argument arc-tangent in radians.

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

The first argument defaults to 1, so in the first case the function will return the angle θ in radians between a vector that goes from origin to the point (3, 1) and the x axis.

(Cool) routine 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) $number, Numeric(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) routine exp

Defined as:

multi sub exp(Cool:D $pow, Cool: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␤»

Pay attention to types when using this method, as ending up with the wrong type may affect the precision you seek to achieve. For Real types, the type of the result is the type of the argument (Complex argument gets coerced to Real, ending up a Num). If rounding a Complex, the result is Complex as well, regardless of the type of the argument.

9930972392403501.round(1)      .perl.say; # OUTPUT: «9930972392403501␤» 
9930972392403501.round(1e0)    .perl.say; # OUTPUT: «9.9309723924035e+15␤» 
9930972392403501.round(1e0).Int.perl.say; # OUTPUT: «9930972392403500␤»

(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) method fmt

Defined as:

method fmt($format = '%s')

Uses $format to return a formatted representation of the invocant; equivalent to calling sprintf with $format as format and the invocant as the second argument. The $format will be coerced to Stringy and defaults to '%s'.

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

Defined as:

method path()

DEPRECATED. It's been deprecated as of the 6.d version. Will be removed in the next ones.

Stringifies the invocant and converts it to IO::Path object. Use the .IO method instead.

(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:

multi sub chars(Cool $x)
multi sub chars(Str:D $x)
multi sub chars(str $x --> int)
method chars(--> Int:D)

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␤» 
say 'ã̷̠̬̊'.chars;     # OUTPUT: «1␤» 
say '👨‍👩‍👧‍👦🏿'.chars;    # OUTPUT: «1␤»

If the string is native, the number of chars will be also returned as a native int.

Graphemes are user visible characters. That is, this is what the user thinks of as a “character”.

Graphemes can contain more than one codepoint. Typically the number of graphemes and codepoints differs when Prepend or Extend characters are involved (also known as Combining characters), but there are many other cases when this may happen. Another example is \c[ZWJ] (Zero-width joiner).

You can check Grapheme_Cluster_Break property of a character in order to see how it is going to behave:

say ‘ã̷̠̬̊’.uniprops(‘Grapheme_Cluster_Break’); # OUTPUT: «(Other Extend Extend Extend Extend)␤» 
say ‘👨‍👩‍👧‍👦🏿’.uniprops(‘Grapheme_Cluster_Break’); # OUTPUT: «(E_Base_GAZ ZWJ E_Base_GAZ ZWJ E_Base_GAZ ZWJ E_Base_GAZ E_Modifier)␤»

You can read more about graphemes in the Unicode Standard, which Perl 6 tightly follows, using a method called NFG, normal form graphemes for efficiently representing them.

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

The same result will be obtained with

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

ords first obtains the actual codepoints, so there might be a difference in speed.

(Cool) routine flip

Defined as:

sub flip(Cool $s --> Str:D)
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 = &tclc, Mu :$where = True)
method wordcase(:&filter = &tclc, Mu :$where = True)

Coerces the invocant (or in sub form, the first argument) to Str, and filters each word that smartmatches 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 $string, Cool $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.

Note: 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) routine uniprop

Defined as:

multi sub uniprop(Str:D, |c)
multi sub uniprop(Int:D $code)
multi sub uniprop(Int:D $code, Stringy:D $propname)
multi method uniprop(|c)

Returns the unicode property of the first character. If no property is specified returns the General Category. Returns a Bool for Boolean properties. A uniprops routine can be used to get the property for every character in a string.

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

(Cool) sub uniprops

Defined as:

sub uniprops(Str:D $str, Stringy: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, but for each character in the passed string.

(Cool) routine uniname

Defined as:

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

Interprets the invocant or 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, and uniparse for the opposite direction.

# Camelia in Unicode 
say ‘»ö«’.uniname;
# OUTPUT: «"RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK"␤» 
say "Ḍ̇".uniname; # Note, doesn't show "COMBINING DOT ABOVE" 
# OUTPUT: «"LATIN CAPITAL LETTER D WITH DOT BELOW"␤» 
 
# Find the char with the longest Unicode name. 
say (0..0x1FFFF).sort(*.uniname.chars)[*-1].chr.uniname;
# OUTPUT: ««ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM␤»␤»

(Cool) routine 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;
# OUTPUT: «("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK", "LATIN SMALL LETTER O WITH DIAERESIS", "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK").Seq␤»

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;
# OUTPUT: «(("LATIN CAPITAL LETTER D WITH DOT BELOW", "COMBINING DOT ABOVE").Seq, ("APOSTROPHE",).Seq, ("LATIN SMALL LETTER O",).Seq, ("LATIN SMALL LETTER H",).Seq)␤»

See uniparse for the opposite direction.

(Cool) routine unimatch

Defined as:

multi sub unimatch(Str:D $str, |c)
multi unimatch(Int:D $code, Stringy:D $pvalname, Stringy: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, |c)
method substr(|c)

Coerces the invocant (or in the sub form, the first argument) to Str, and calls Str.substr with the arguments.

(Cool) routine substr-rw

Defined as:

multi method substr-rw(|) is rw
multi sub substr-rw(|) is rw

Coerces the invocant (or in the sub form, the first argument) to Str, and calls Str.substr-rw with the arguments.

(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. If you are only interested in the number of codepoints, codes is a possibly faster option.

(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 $delimiter, Str(Cool) $input, $limit = Inf, :$k, :$v, :$kv, :$p, :$skip-empty)
multi sub    split(Regex:D $delimiter, Str(Cool) $input, $limit = Inf, :$k, :$v, :$kv, :$p, :$skip-empty)
multi sub    split(@delimiters, Str(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)

[1]

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

(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(Cool:D: |c)

Coerces the invocant (or first argument, if it is called as a subroutine) to Str, and returns a list of words that make up the string. Check Str.words for additional arguments and its meaning.

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

Cool is the base class for many other classes, and some of them, like Match, can be converted to a string. This is what happens in this case:

say ( "easy come, easy goes" ~~ m:g/(ea\w+)/).words(Inf);
# OUTPUT: «(easy easy)␤» 
say words( "easy come, easy goes" ~~ m:g/(ea\w+)/ , ∞);
# OUTPUT: «(easy easy)␤»

The example above illustrates two of the ways words can be invoked, with the first argument turned into invocant by its signature. Of course, Inf is the default value of the second argument, so in both cases (and forms) it can be simply omitted.

Only whitespace (including no-break space) counts as word boundaries

say <Don't we ♥ Perl 6>.words.join('|');  # OUTPUT: «Don't|we|♥|Perl|6␤»

In this case, Perl 6 includes an (visible only in the source) no-break space; words still splits the (resulting) Str on it, even if the original array only had 4 elements:

say <Don't we ♥ Perl 6>.join("|");  # OUTPUT: «Don't|we|♥|Perl 6␤»

Please see Str.words for more examples and ways to invoke it.

(Cool) routine comb

Defined as:

multi sub comb(Regex $matcher, Cool $input, $limit = *)
multi sub comb(Str $matcher, Cool $input, $limit = *)
multi sub comb(Int:D $size, Cool $input, $limit = *)
multi method comb(|c)

Returns a Seq of all (or if supplied, at most $limit) matches of the invocant (method form) or the second argument (sub form) against the Regex, string or defined number.

say "6 or 12".comb(/\d+/).join(", ");           # OUTPUT: «6, 12␤» 
say comb(/\d <[1..9]> /,(11..30)).join("--");
# OUTPUT: 
# «11--12--13--14--15--16--17--18--19--21--22--23--24--25--26--27--28--29␤»

The second statement exemplifies the first form of comb, with a Regex that excludes multiples of ten, and a Range (which is Cool) as $input. comb stringifies the Range before applying .comb on the resulting string. Check Str.comb for its effect on different kind of input strings. When the first argument is an integer, it indicates the (maximum) size of the chunks the input is going to be divided in

say comb(3,[3,33,333,3333]).join("*");  # OUTPUT: «3 3*3 3*33 *333*3␤»

In this case the input is a list, which after transformation to Str (which includes the spaces) is divided in chunks of size 3.

(Cool) method contains

Defined as:

method contains(Cool:D: |c)

Coerces the invocant Str, and calls Str.contains on it. Please refer to that version of the method for arguments and general syntax.

say 123.contains("2")# OUTPUT: «True␤»

Since Int is a subclass of Cool, 123 is coerced to a Str and then contains is called on it.

say (1,1, * + * … * > 250).contains(233)# OUTPUT: «True␤»

Seqs are also subclasses of Cool, and they are stringified to a comma-separated form. In this case we are also using an Int, which is going to be stringified also; "233" is included in that sequence, so it returns True. Please note that this sequence is not lazy; the stringification of lazy sequences does not include each and every one of their components for obvious reasons.

(Cool) routine index

Defined as:

multi sub index(Cool $s, Cool $needle, Cool $pos = 0)
method    index(Cool:D: |c)

Coerces the first two arguments (in method form, also counting the invocant) to a Str, and searches for $needle in the string $s 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) $haystack, Str(Cool) $needle, Int(Cool) $startpos = $haystack.chars)
multi method rindex(Str(Cool) $haystack: Str(Cool) $needle, Int(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) method match

Defined as:

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

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

(Cool) routine roots

Defined as:

multi sub roots(Numeric(Cool) $x, Int(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);
}
 
# OUTPUT:«2+0i 1.22464679914735e-16+2i -2+2.44929359829471e-16i -3.67394039744206e-16-2i␤» 
# OUTPUT:«1.77635683940025e-15␤» 
# OUTPUT:«4.30267170434156e-15␤» 
# OUTPUT:«8.03651692704705e-15␤» 
# OUTPUT:«1.04441561648202e-14␤» 

(Cool) method match

Defined as:

method match(|)

Coerces the invocant to Stringy and calls Str.match.

(Cool) method subst

Defined as:

method subst(|)

Coerces the invocant to Stringy and calls Str.subst.

(Cool) method trans

Defined as:

method trans(|)

Coerces the invocant to Str and calls Str.trans

(Cool) method IO

Defined as:

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

Coerces the invocant to IO::Path.

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