Raku Documentation
class Slip
A kind of List that automatically flattens into an outer container
is List
A Slip is a List that automatically flattens into an outer List (or other list-like container or iterable).
For example it allows you to write a map that produces more than one value into the result without nesting:
say <a b c>.map().join('|'); # OUTPUT: «a|A|b|B|c|C»
In contrast, when returning an ordinary List, the resulting list is nested:
say <a b c>.map().join('|'); # OUTPUT: «a A|b B|c C»
To create a Slip, either coerce another list-like type to it by calling the Slip method, or use the slip subroutine:
# This says "1" and then says "2", rather than saying "(1 2)".say for gather
A Slip may also be created by using the prefix:<|> operator. This differs from the slip subroutine in both precedence and treatment of single arguments. In fact, prefix:<|> only takes a single argument, so in that way, it behaves closer to the .Slip method than the slip subroutine.
my = (1, 2, 3);say (1, slip 2, 3).raku; # says (1, 2, 3) , slips 2, 3 into (1, …)say (0, slip , 4).raku; # says (0, $(1, 2, 3), 4) , $l does not break apartsay (0, slip ).raku; # says (0, 1, 2, 3) , slips from $l into (0, …)say (0, .Slip).raku; # says (0, 1, 2, 3) , slips from $l into (0, …)say (0, .Slip, 4).raku; # says (0, 1, 2, 3, 4) , slips from $l into (0, …, 4)say (|).raku; # says slip(1, 2, 3) , breaks apart $lsay (0, (|, 4), 5); # says (0 (1 2 3 4) 5) , slips from $l into (…, 4)say (0, (.Slip, 4), 5); # says (0 (1 2 3 4) 5) , slips from $l into (…, 4)say (0, (slip , 4), 5); # says (0 (1 2 3) 4 5) , slips ($l, 4) into (0, …, 5)say (0, (, 4).Slip, 5); # says (0 (1 2 3) 4 5) , slips ($l, 4) into (0, …, 5)
Loops that do not want to produce a value for an iteration use Slips, rather than empty Lists to do so, as do if statements that do not run their blocks.
Please note that prefix:<|> will also apply parameters in a slippy manner to a routine call. It does not forward a Slip to the called routine, that includes return and take.
my \l = gather for 1..10 -> , ; say l.raku;# OUTPUT: «((1, 2), (3, 4), (5, 6), (7, 8), (9, 10)).Seq»my \m= gather for 1..10 -> , ; say m.raku;# OUTPUT: «(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Seq»
Methods
method List
Defined as:
multi method List(Slip: --> List)
Turns it into a list.
sub slip
Defined as:
multi sub slip(--> Empty)multi sub slip( --> Slip)multi sub slip(+args --> Slip)
Creates a Slip from its arguments by calling .Slip on the object formed by them. Returns Empty if called with void arguments.
Constants
constant Empty
Empty is a Slip of the empty List.
say "".comb ~~ Empty;# OUTPUT: «True»
For example, these constructs with a failing test return Empty:
do if 0 ;(42 if 0);do with Any ;(42 with Any);
Type Graph
Slip
Routines supplied by class List
Slip inherits from class List, which provides the following routines:
(List) method ACCEPTS
Defined as:
multi method ACCEPTS(List: )
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.
(List) routine list
Defined as:
multi sub list(+list)multi method list(List:)
The method just returns the invocant self. The subroutine adheres to the single argument rule: if called with a single argument that is a non-itemized Iterable it returns a List based on the argument's iterator; otherwise it just returns the argument list.
For example:
my = (1, 2); # an itemized Listput .list.raku; # OUTPUT: «(1, 2)»put list().raku; # OUTPUT: «($(1, 2),)»put list(|).raku; # OUTPUT: «(1, 2)»
The last statement uses the prefix:<|> operator to flatten the tuple into an argument list, so it is equivalent to:
put list(1, 2).raku; # OUTPUT: «(1, 2)»
There are other ways to list the elements of an itemized single argument. For example, you can decontainerize the argument or use the @ list contextualizer:
put list(<>).raku; # OUTPUT: «(1, 2)»put list(@).raku; # OUTPUT: «(1, 2)»
Note that converting a type object to a list may not do what you expect:
put List.list.raku; # OUTPUT: «(List,)»
This is because the .list candidate accepting a type object as the invocant is provided by Any. That candidate returns a list with one element: the type object self. If you're developing a collection type whose type object should be a valid representation of an empty collection, you may want to provide your own candidate for undefined invocants or override the Any: candidates with an "only" method. For example:
mymy LinkedList ; # an empty linked listput .list.raku; # OUTPUT: «()»
(List) routine elems
Defined as:
sub elems( --> Int)method elems(List: --> Int)
Returns the number of elements in the list.
say (1,2,3,4).elems; # OUTPUT: «4»
(List) routine end
Defined as:
sub end( --> Int)method end(List: --> Int)
Returns the index of the last element.
say (1,2,3,4).end; # OUTPUT: «3»
(List) routine keys
Defined as:
sub keys( --> Seq)method keys(List: --> Seq)
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( --> Seq)method values(List: --> Seq)
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»
(List) routine kv
Defined as:
sub kv( --> Seq)method kv(List: --> Seq)
Returns an interleaved sequence of indexes and values. For example
say <a b c>.kv; # OUTPUT: «(0 a 1 b 2 c)»
(List) routine pairs
Defined as:
sub pairs( --> Seq)method pairs(List: --> Seq)
Returns a sequence of pairs, with the indexes as keys and the list values as values.
say <a b c>.pairs; # OUTPUT: «(0 => a 1 => b 2 => c)»
(List) routine antipairs
Defined as:
method antipairs(List: --> Seq)
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 invert
Defined as:
method invert(List: --> Seq)
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 = List.new('a' => (2, 3), 'b' => 17);say .invert; # OUTPUT: «(2 => a 3 => a 17 => b)»
(List) routine join
Defined as:
sub join(, *)method join(List: = "")
Treats the elements of the list as strings by calling .Str on each of them, interleaves them with $separator and concatenates everything into a single string.
Example:
say join ', ', <a b c>; # OUTPUT: «a, b, c»
The method form also allows you to omit the separator:
say <a b c>.join; # OUTPUT: «abc»
Note that the method form does not flatten sublists:
say (1, <a b c>).join('|'); # OUTPUT: «1|a b c»
The subroutine form behaves slurpily, flattening all arguments after the first into a single list:
say join '|', 1, <a b c>; # OUTPUT: «1|a|b|c»
In this case, the 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)»
(List) routine map
Defined as:
multi method map(Hash \hash)multi method map(Iterable \iterable)multi method map(|c)multi method map(\SELF: ;; :, :)multi sub map(, +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: # 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(, ) ;say <a b x y>.map().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()
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;s# OUTPUT: «hi»
(List) method flatmap
Defined as:
method flatmap(List: --> Seq)
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
## flatmapmy = ('first1', ('second2', ('third3', 'third4'), 'second5'), 'first6');say .flatmap().raku;# OUTPUT: «("first1", "second5", "third3", "third4", "second2", "first6").Seq»## mapsay .map().raku;# OUTPUT: «("first1 was a Str", "second2 third3 third4 second5 was a List", "first6 was a Str").Seq»## .map .flat has the same output as .flatmapsay .map().flat.raku;# OUTPUT: «("first1", "second5", "third3", "third4", "second2", "first6").Seq»
(List) method gist
Defined as:
multi method gist(List: --> Str)
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 ...)
(List) routine grep
Defined as:
sub grep(Mu , *, :, :, :, : --> Seq)method grep(List: Mu , :, :, :, : --> Seq)
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 , '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() # 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 , :kv, 'hello', 1, 22/7, 42, 'world';# OUTPUT: «(0 hello 2 3.142857 4 world)»say grep , :p, 'hello', 1, 22/7, 42, 'world';# OUTPUT: «(0 => hello 2 => 3.142857 4 => world)»
(List) routine first
Defined as:
sub first(Mu , *, :, :, :, :)method first(List: Mu ?, :, :, :, :)
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.
(List) method head
Defined as:
multi method head(Any:) is rawmulti method head(Any: Callable )multi method head(Any: )
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)»
(List) method tail
Defined as:
multi method tail(List:)multi method tail(List: --> Seq)
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( ); # OUTPUT: «(c d e)»
(List) routine categorize
Defined as:
multi method categorize()multi method categorize(Whatever)multi method categorize(, :!, :)multi method categorize(, :)multi sub categorize(, +items, :!, * )multi sub categorize(, +items, * )
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 ) returns Listsay categorize , (1, 7, 6, 3, 2);# OUTPUT: «{even => [6 2], not prime => [1 6], odd => [1 7 3], prime => [7 3 2]}»
(List) routine classify
Defined as:
multi method classify(, :!, :)multi method classify(, :)multi sub classify(, +items, :!, * )multi sub classify(, +items, * )
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 , (1, 7, 6, 3, 2);# OUTPUT: «{even => [6 2], odd => [1 7 3]}»say ('hello', 1, 22/7, 42, 'world').classify: ;# 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( , :as);# 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( , :as, :into( my ) );say ; # 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.
(List) method Bool
Defined as:
method Bool(List: --> Bool)
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: --> Str)
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: --> Int)
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: --> Int)
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(List: --> Capture)
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 = (7, 5, a => 2, b => 17);my = .Capture;say .keys; # OUTPUT: «(0 1 a b)»my-sub(|); # OUTPUT: «7, 5, 2, 17»sub my-sub(, , :, :)
A more advanced example demonstrating the returned Capture being matched against a Signature.
my = (7, 5, a => 2, b => 17);say so .Capture ~~ :($ where * == 7,$,:,:); # OUTPUT: «True»= (8, 5, a => 2, b => 17);say so .Capture ~~ :($ where * == 7,$,:,:); # OUTPUT: «False»
(List) routine pick
Defined as:
multi sub pick(, * --> Seq)multi method pick(List: --> Seq)multi method pick(List: --> 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)»
(List) routine roll
Defined as:
multi sub roll(, * --> Seq)multi method roll(List: --> Seq)multi method roll(List: --> 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 lettersay <a b c d e>.roll: 3; # 3 random letterssay roll 8, <a b c d e>; # 8 random lettersmy := (^10).roll(*);say [^15]; # 15 random digits
(List) routine eager
Defined as:
multi method eager(List: --> List)
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)»
(List) routine reverse
Defined as:
multi sub reverse(* --> Seq)multi method reverse(List: --> Seq)
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)»
(List) routine rotate
Defined as:
multi sub rotate(, Int = 1 --> Seq)multi method rotate(List: Int = 1 --> Seq)
Returns a Seq with the list elements rotated to the left when $n is positive or to the right otherwise.
Examples:
say <a b c d e>.rotate(2); # OUTPUT: (c d e a b)say <a b c d e>.rotate(-1); # OUTPUT: (e a b c d)
Note: Before Rakudo version 2020.06 a new List was returned instead of a Seq.
(List) routine sort
Defined as:
multi sub sort(* --> Seq)multi sub sort(, * --> Seq)multi method sort(List: --> Seq)multi method sort(List: --> Seq)
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: ; # 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 = (%( first-name => 'Kyle', last-name => 'Reese' ),%( first-name => 'Sarah', last-name => 'Connor' ),%( first-name => 'John', last-name => 'Connor' ),);.say for .sort: ;#`(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( );# 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( );# OUTPUT: «(01 02 2 11 20 111)»
(List) routine reduce
Defined as:
multi method reduce(Any: )multi sub reduce (, +list)
Returns a single "combined" value from a list of arbitrarily many values, by iteratively applying a routine which knows how to combine two values. In addition to the subroutine and the list, an initial value can be provided to initialize the reduction, which ends up being the return value if the list is empty. Thus reduce f, init, list combines the elements of the list from left to right, as is shown in the following pseudocode:
result0 = initresult1 = f(result0, list[0])result2 = f(result1, list[1])...resultn = f(resultn-1, list[n-1])
resultn is the final result for an n-element list.
say reduce :<+>, (1, 2, 3); # OUTPUT: «6»say (1, 2, 3).reduce: :<+>; # OUTPUT: «6»say reduce , (5, 9, 12, 1); # OUTPUT: «12»
If list contains just a single element, the operator is applied to that single element if possible; if not, it returns the element itself.
say reduce :<->, (10,); # OUTPUT: «10»
When the list contains no elements, an exception is thrown, unless &with is an operator with a known identity value (e.g., the identity value of infix:<+> is 0). For this reason, you're advised to prefix the input list with an initial value (or explicit identity value):
my \strings = "One good string!", "And one another good string!";say reduce , '', |strings; # like strings.joinmy \numbers = 1, 2, 3, 4, 5;say reduce , 0, |numbers; # like numbers.maxsub count-and-sum-evens( (Int \count, Int \sum), Int \x )say reduce , (0, 0), |numbers; # OUTPUT: «(2 6)»
In the last example, since reduce only supports one initial value we use a List with two values, which is by itself a single value. The count-and-sum-evens subroutine takes two positional values: a List of two Ints and an Int, and return a List storing the count and sum of the even integers accumulated.
If &with is the code object of an operator, its inherent identity value and associativity is respected - in other words, (VAL1, VAL2, VAL3).reduce(&infix:<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 reduction metaoperator [ ] provides a syntactic shortcut. Thus, instead of passing the operator's code object to reduce, just pass the operator directly to [ ]. To use a user-defined subroutine instead, provide an additional layer of square brackets around the subroutine's code object:
say [*] (1, 2, 3, 4); # OUTPUT: «24»say [min] (4, 2, 1, 3); # OUTPUT: «1»sub mult ;say [[]] (1, 2, 3, 4); # OUTPUT: «24»
Semantically, all the following do the same thing:
my \numbers = 1, 2, 3, 4, 5;say reduce , 0, |numbers;say reduce * + *, 0, |numbers;say reduce &[+], numbers; # operator does not need explicit identity valuesay [+] numbers;
Since reduce is an implicit loop that iterates over with its reducing subroutine, it responds to next, last and redo statements inside &with:
sub last-after-seven ;say (2, 3, 4, 5).reduce: ; # OUTPUT: «9»
Whether reduce accumulates the elements starting from the left or from the right depends on the operator. 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. In Raku, you can specify the associativity of an operator with the is assoc.
sub infix:<foo>(, ) is assoc<right>say [foo] 1, 2, 3, 4; # OUTPUT: «(1, (2, (3, 4)))»sub infix:<bar>(, ) is assoc<left>say [bar] 1, 2, 3, 4; # OUTPUT: «(((1, 2), 3), 4)»
Practical example 1: In this example, we generate a random-ish math formula (e.g., "(4 + ((3 * x) + 11) / 6))") using reduce.
my = [Z] (<+ - * />, 1..20)».roll(4);say ('x', |).reduce: -> , [, ]
Practical example 2: Suppose we have a polynomial represented as a list of integer coefficients, c[n-1], c[n-2], ..., c[0], where c[i] is the coefficient of xi. We can evaluate it using map and reduce as follows:
sub evaluate(List \c where c.all ~~ Int, Rat \x --> Rat)my \c = 2, 3, 1; # 2x² + 3x + 1say evaluate c, 3.0; # OUTPUT: «28»say evaluate c, 10.0; # OUTPUT: «231»
(List) routine produce
Defined as:
multi sub produce(, *)multi method produce(List: )
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 = (1,2,3,4,5);say produce , ;say produce * + *, ;say produce &[+], ; # operator does not need explicit identitysay [\+] ; # 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: ; # OUTPUT: «(2 5 9)»
(List) routine combinations
Defined as:
multi sub combinations(, = 0..* --> Seq)multi method combinations(List: Int() --> Seq)multi method combinations(List: Iterable = 0..* --> Seq)
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.
(List) routine permutations
Defined as:
multi sub permutations(Int() --> Seq)multi sub permutations(Iterable --> Seq)multi method permutations(List: --> Seq)
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)
(List) method rotor
Defined as:
method rotor(*, Bool() : --> Seq)
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.
(List) method batch
Defined As:
multi method batch(Int --> Seq)multi method batch(Int : --> Seq)
Returns a sequence of lists, wherein each list with the exception of the last one is guaranteed to comprise a number of elements equal to the batch size specified by $batch or $elems, respectively. If the invocant has a number of elements that is not an integer multiple of the batch size, the last list in the returned sequence will contain any remaining elements and thus have less than $batch or $elems elements. Accordingly, .batch($batch) is shorthand for .rotor($batch, :partial).
(List) routine cross
sub cross(+, : --> Seq)
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(:<*>)).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
(List) routine zip
Defined as:
sub zip(+, : --> Seq)
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> -> [,,]# OUTPUT: «a,d,gb,e,hc,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(:<*>);# OUTPUT: «1827»
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
(List) 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,32,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,32,3,457,10277»
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( )method sum(List:)
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»
If the list includes a Junction, the result will accordingly be a Junction:
say ( 1|2, 3).sum; # OUTPUT: «any(4, 5)»
When called on native integer arrays, it is also possible to specify a :wrap named parameter. This will add the values as native integers, wrapping around if they exceed the size of a native integer. If you are 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 = ^1_000_000;say .sum(:wrap); # OUTPUT: «499999500000»
(List) method fmt
Defined as:
method fmt( = '%s', = ' ' --> Str)
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 = 8..11;say .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.
(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: «»
(List) 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 = (:42a, :33b);say ; # OUTPUT: «[a => 42 b => 33]»say .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.
(List) infix cmp
multi sub infix:<cmp>(List , List )
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»
Routines supplied by class Cool
Slip inherits from class Cool, which provides the following routines:
(Cool) routine abs
Defined as:
sub abs(Numeric() )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) method 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) )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 Raku 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(, = 1e0)method atan2( = 1e0)
The sub should usually be written with two arguments for clarity as it is seen in other languages and in mathematical texts, but the single-argument form is available; its result will always match that of atan.
say atan2 3, 1; # OUTPUT: «1.2490457723982544»say atan2 3; # OUTPUT: «1.2490457723982544»say atan2 ⅔, ⅓; # OUTPUT: «1.1071487177940904»
The method coerces self and its single 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 $x argument in either the method or the sub defaults to 1 so, in both single-argument cases, the function will return the angle θ in radians between the x-axis and a vector that goes from the origin to the point (3, 1).
(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) , Numeric(Cool) ?)multi method log(Cool: Cool ?)
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 method log10()multi sub log10(Numeric )multi sub log10(Cool )
Coerces the invocant (or in the sub form, the argument) to Numeric (or uses it directly if it's already in that form), and returns its Logarithm in base 10, that is, a number that approximately produces the original number when 10 is raised to its power. Returns NaN for negative arguments and -Inf for 0.
say log10(1001); # OUTPUT: «3.00043407747932»
(Cool) routine log2
Defined as:
multi method log2()multi sub log2(Numeric )multi sub log2(Cool )
Coerces the invocant to Numeric, and returns its Logarithm in base 2, that is, a number that approximately (due to computer precision limitations) produces the original number when 2 is raised to its power. Returns NaN for negative arguments and -Inf for 0.
say log2(5); # OUTPUT: «2.321928094887362»say "4".log2; # OUTPUT: «2»say 4.log2; # OUTPUT: «2»
(Cool) routine exp
Defined as:
multi sub exp(Cool , Cool ?)multi method exp(Cool: Cool ?)
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), = 1)multi method round(Cool: = 1)
Coerces the invocant (or in sub form, its argument) to Numeric, and rounds it to the unit of $scale. If $scale is 1, rounds to the nearest integer; an arbitrary scale will result in the closest multiple of that number.
say 1.7.round; # OUTPUT: «2»say 1.07.round(0.1); # OUTPUT: «1.1»say 21.round(10); # OUTPUT: «20»say round(1000, 23.01) # OUTPUT: «989.43»
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) .raku.say; # OUTPUT: «9930972392403501»9930972392403501.round(1e0) .raku.say; # OUTPUT: «9.9309723924035e+15»9930972392403501.round(1e0).Int.raku.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( = '%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 )multi sub chars(Str )multi sub chars(str --> int)method chars(--> Int)
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 Raku 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 --> Str)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 = ' 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 = ' 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 = ' 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) , : = , Mu : = True)method wordcase(: = , Mu : = 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 "raku programming".wordcase; # OUTPUT: «Raku Programming»
With a matcher:
say "have fun working on raku".wordcase(:where());# Have fun Working on Raku
With a customer filter too:
say "have fun working on raku".wordcase(:filter(), :where());# HAVE fun WORKING on RAKU
(Cool) routine samecase
Defined as:
sub samecase(Cool , Cool )method samecase(Cool: Cool )
Coerces the invocant (or in sub form, the first argument) to Str, and calls Str.samecase on it.
say "raKu".samecase("A_a_"); # OUTPUT: «Raku»say "rAKU".samecase("Ab"); # OUTPUT: «Raku»
(Cool) routine uniprop
Defined as:
multi sub uniprop(Str, |c)multi sub uniprop(Int )multi sub uniprop(Int , Stringy )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 , Stringy = "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 Unicodesay ‘»ö«’.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)[].chr.uniname;# OUTPUT: «BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT AND MIDDLE LEFT TO LOWER CENTRE»
(Cool) routine uninames
Defined as:
sub uninames(Str)method uninames()
Returns of a Seq of Unicode names for the all the codepoints in the Str provided.
say ‘»ö«’.uninames.raku;# 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.raku;# 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 , |c)multi sub unimatch(Int , Stringy , Stringy = )
Checks if the given integer codepoint or the first letter of the given string has 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: «False»
The last property corresponds to "lowercase letter", which explains why it returns false.
(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 'raku'.chop; # OUTPUT: «rak»
(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) , |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 rwmulti 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) )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(* --> Str)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 , Str(Cool) , = Inf, :, :, :, :, :)multi sub split(Regex , Str(Cool) , = Inf, :, :, :, :, :)multi sub split(, Str(Cool) , = Inf, :, :, :, :, :)multi method split( Str , = Inf, :, :, :, :, :)multi method split(Regex , = Inf, :, :, :, :, :)multi method split(, = Inf, :, :, :, :, :)
Coerces the invocant (or in the sub form, the second argument) to Str, splits it into pieces based on delimiters found in the string and returns the result as a Seq.
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, which can mix Cool and Regex objects.
say split(';', "a;b;c").raku; # OUTPUT: «("a", "b", "c").Seq»say split(';', "a;b;c", 2).raku; # OUTPUT: «("a", "b;c").Seq»say split(';', "a;b;c,d").raku; # OUTPUT: «("a", "b", "c,d").Seq»say split(/\;/, "a;b;c,d").raku; # OUTPUT: «("a", "b", "c,d").Seq»say split(//, "a;b;c,d").raku; # OUTPUT: «("a", "b", "c", "d").Seq»say split(['a', /b+/, 4], '1a2bb345').raku; # OUTPUT: «("1", "2", "3", "5").Seq»
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: /","/ ).raku; # OUTPUT: «("f", "", "b", "c", "d").Seq»say ("f,,b,c,d".split: /","/, :skip-empty).raku; # OUTPUT: «("f", "b", "c", "d").Seq»
(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 -># or if you'll be processing latermy = 'huge-csv'.IO.lines;
Without any arguments, sub lines operates on $*ARGFILES.
To modify values in place use is copy to force a writable container.
for .lines -> is copy
(Cool) method words
Defined as:
method words(Cool: |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 <Flying on a Boeing 747>.words.join('|'); # OUTPUT: «Flying|on|a|Boeing|747»
In this case, "Boeing 747" includes a (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 <Flying on a Boeing 747>.join('|'); # OUTPUT: «Flying|on|a|Boeing 747»
Please see Str.words for more examples and ways to invoke it.
(Cool) routine comb
Defined as:
multi sub comb(Regex , Cool , = *)multi sub comb(Str , Cool , = *)multi sub comb(Int , Cool , = *)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 /,(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: |c)
Coerces the invocant to a 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 , Cool , :i(:), :m(:) --> Int)multi sub index(Cool , Cool , Cool , :i(:), :m(:) --> Int)multi method index(Cool: Cool --> Int)multi method index(Cool: Cool , :m(:)! --> Int)multi method index(Cool: Cool , :i(:)!, :m(:) --> Int)multi method index(Cool: Cool , Cool --> Int)multi method index(Cool: Cool , Cool , :m(:)! --> Int)multi method index(Cool: Cool , Cool , :i(:)!, :m(:) --> Int)
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 $pos. It returns the offset into the string where $needle was found, and Nil if it was not found.
See the documentation in type Str for examples.
(Cool) routine rindex
Defined as:
multi sub rindex(Cool , Cool --> Int)multi sub rindex(Cool , Cool , Cool --> Int)multi method rindex(Cool: Cool --> Int)multi method rindex(Cool: Cool , Cool --> Int)
Coerces the first two arguments (including the invocant in method form) to Str and $pos to Int, and returns the last position of $needle in the string not after $pos. Returns Nil if $needle wasn't found.
See the documentation in type Str for examples.
(Cool) method match
Defined as:
method match(Cool: , *)
Coerces the invocant to Stringy and calls the method match on it.
(Cool) routine roots
Defined as:
multi sub roots(Numeric(Cool) , Int(Cool) )multi method roots(Int(Cool) )
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 = 16;my = .roots(4);say ;for -># 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 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)
Coerces the invocant to IO::Path.
.say for '.'.IO.dir; # gives a directory listing
(Cool) method sprintf
Defined as:
method sprintf(*)
Returns a string according to a series format directives that are common in many languages; the object will be the format string, while the supplied arguments will be what's going to be formatted according to it.
"% 6s".sprintf('Þor').say; # OUTPUT: « Þor»
(Cool) method printf
Defined as:
method printf(*)
Uses the object, as long as it is a format string, to format and print the arguments
"%.8f".printf(now - now ); # OUTPUT: «-0.00004118»
(Cool) method Complex
Defined as:
multi method Complex()
Coerces the invocant to a Numeric and calls its .Complex method. Fails if the coercion to a Numeric cannot be done.
say 1+1i.Complex; # OUTPUT: «1+1i»say π.Complex; # OUTPUT: «3.141592653589793+0i»say <1.3>.Complex; # OUTPUT: «1.3+0i»say (-4/3).Complex; # OUTPUT: «-1.3333333333333333+0i»say "foo".Complex.^name; # OUTPUT: «Failure»
(Cool) method FatRat
Defined as:
multi method FatRat()
Coerces the invocant to a Numeric and calls its .FatRat method. Fails if the coercion to a Numeric cannot be done.
say 1+0i.FatRat; # OUTPUT: «1»say 2e1.FatRat; # OUTPUT: «20»say 1.3.FatRat; # OUTPUT: «1.3»say (-4/3).FatRat; # OUTPUT: «-1.333333»say "foo".FatRat.^name; # OUTPUT: «Failure»
(Cool) method Int
Defined as:
multi method Int()
Coerces the invocant to a Numeric and calls its .Int method. Fails if the coercion to a Numeric cannot be done.
say 1+0i.Int; # OUTPUT: «1»say <2e1>.Int; # OUTPUT: «20»say 1.3.Int; # OUTPUT: «1»say (-4/3).Int; # OUTPUT: «-1»say "foo".Int.^name; # OUTPUT: «Failure»
(Cool) method Num
Defined as:
multi method Num()
Coerces the invocant to a Numeric and calls its .Num method. Fails if the coercion to a Numeric cannot be done.
say 1+0i.Num; # OUTPUT: «1»say 2e1.Num; # OUTPUT: «20»say (16/9)².Num; # OUTPUT: «3.1604938271604937»say (-4/3).Num; # OUTPUT: «-1.3333333333333333»say "foo".Num.^name; # OUTPUT: «Failure»
(Cool) method Rat
Defined as:
multi method Rat()
Coerces the invocant to a Numeric and calls its .Rat method. Fails if the coercion to a Numeric cannot be done.
say 1+0i.Rat; # OUTPUT: «1»say 2e1.Rat; # OUTPUT: «20»say (-4/3).Rat; # OUTPUT: «-1.333333»say "foo".Rat.^name; # OUTPUT: «Failure»say (.numerator, .denominator) for π.Rat; # OUTPUT: «(355 113)»
(Cool) method Real
Defined as:
multi method Real()
Coerces the invocant to a Numeric and calls its .Real method. Fails if the coercion to a Numeric cannot be done.
say 1+0i.Real; # OUTPUT: «1»say 2e1.Real; # OUTPUT: «20»say 1.3.Real; # OUTPUT: «1.3»say (-4/3).Real; # OUTPUT: «-1.333333»say "foo".Real.^name; # OUTPUT: «Failure»
(Cool) method UInt
Defined as:
multi method UInt()
Coerces the invocant to an Int. Fails if the coercion to an Int cannot be done or if the Int the invocant had been coerced to is negative.
say 1+0i.UInt; # OUTPUT: «1»say 2e1.UInt; # OUTPUT: «20»say 1.3.UInt; # OUTPUT: «1»say (-4/3).UInt.^name; # OUTPUT: «Failure»say "foo".UInt.^name; # OUTPUT: «Failure»
Routines supplied by role Positional
Slip inherits from class List, which does role Positional, which provides the following routines:
(Positional) method of
method of()
Returns the type constraint for elements of the positional container, that is, the T in the definition above, which, as it can be seen, defaults to Mu. It is returned as a type object.
my ;say .of.^name; # OUTPUT: «Mumy Str ;say .of.raku; # OUTPUT: «Str»say (my int @).of; # OUTPUT: «(int)»
(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, :)
This method should only be supplied if you want to support the:
my 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
Slip inherits from class List, which does role Iterable, which provides the following routines:
(Iterable) method iterator
Defined as:
method iterator(--> Iterator)
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: --> 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').raku; # OUTPUT: «($("a", "b"), "c")»
You can use the hyper method call to call the .List method on all the inner itemized sublists and so de-containerize them, so that flat can flatten them:
say ($('a', 'b'), 'c')>>.List.flat.elems; # OUTPUT: «3»
(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) : = 64, Int(Cool) : = 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().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) : = 64, Int(Cool) : = 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 (mnemonic: in a race, you never know who will arrive first).
say ([1..100].race.map().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.