class List
Sequence of values
my 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 Raku, 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 = (1, 2, 3);for # one iterationfor .list # three iterationsmy = [1, 2, 3];for # one iterationfor .list # three iterationsmy = 1, 2, 3;for # three iterationsfor .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 = (1, 2, 3);my = (, ); # two elementsmy = .map(); # six elements, with explicit Slipmy = <a b>;.append: .list; # The array variable @b has 5 elements, because# the list $a is the sole argument to appendsay .elems; # OUTPUT: «5»my = <a b>;.append: .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 operationsay .elems; # OUTPUT: «4»my = <a b>;.append: ; # The array variable @d has 3 elements, because# $a is in an item context and as far as append is# concerned a single elementsay .elems; # OUTPUT: «3»
The same flattening behavior applies all objects that do the Iterable role, notable hashes:
my = a => 1, b => 2;my = ; say .elems; # OUTPUT: «2»my = , ; say .elems; # OUTPUT: «1»my = $; say .elems; # OUTPUT: «1»
Slurpy parameters (*@a) flatten non-itemized sublists:
sub fe(*)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 ;for , .list, .Seq -> \listoid# OUTPUT: «TrueTrueTrue»
Coercion to Bool also indicates if the List got any elements.
my ;say [.elems, .Bool, ?]; # OUTPUT: «[0 False False]».push: 42;say [.elems, .Bool, ?]; # OUTPUT: «[1 True True]»say 'empty' unless ; # no output
Methods
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.
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»
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»
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»
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»
routine kv
Defined as:
sub kv( --> Seq)method kv(List: --> Seq)
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( --> Seq)method pairs(List: --> Seq)
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: --> 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)»
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)»
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. 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 \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# RESULT: «hi»
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().perl;# OUTPUT «("first1", "second5", "third3", "third4", "second2", "first6").Seq»## mapsay .map().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 .flatmapsay .map().flat.perl# OUTPUT «("first1", "second5", "third3", "third4", "second2", "first6").Seq»
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 ...)
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)»
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.
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)»
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)»
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]}»
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.
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»
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»
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»
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»
method Capture
Defined as:
method Capture(--> 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(|); # RESULT: «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»
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)»
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
routine eager
Defined as:
multi method eager(List: --> List)multi sub eager(* --> 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)»
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)»
routine rotate
Defined as:
multi sub rotate(, Int = 1 --> List)multi method rotate(List: Int = 1 --> List)
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(* --> 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)»
routine reduce
Defined as:
multi method reduce(Any: & --> Nil)multi method reduce(Any: )multi sub reduce (, +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: 2say [-] 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 = ("One good string!", "And one another good string!");say reduce , '', |; # like @strings.joinmy = (1,2,3,4,5);say reduce , 0, |; # 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 = (1,2,3,4,5);say reduce , 0, |;say reduce * + *, 0, |;say reduce &[+], ; # operator does not need explicit identitysay [+] ; # 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: ; # says 9
Practical example:
# Generate a random-ish math formula like "(4 + ((3 * x) + 11) / 6))"my = [Z] (<+ - * />, 1..20)».roll(4);say ('x', |).reduce: -> , [, ]
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>(, ) 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)»
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)»
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.
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)
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.
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).
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
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,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(:<*>);# 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( --> Numeric)method sum(List: --> Numeric)
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 = ^1_000_000;say .sum(:wrap); # OUTPUT: «499999500000»
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»
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 = (: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.
Operators
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»
Type Graph
List
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, :)
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
List 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)
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) : = 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.
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.
Routines supplied by class Cool
List 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) 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) )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:
method atan2( = 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) , 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 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 , 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))multi method round(Cool: = 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( = '%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 perl".wordcase(:where());# Have fun Working on Perl
With a customer filter too:
say "have fun working on perl".wordcase(:filter(), :where());# HAVE fun WORKING on PERL
(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 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 "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: ««ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM»»
(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.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 , |c)multi unimatch(Int , Stringy , Stringy = )
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) , |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, 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 -># or if you'll be processing latermy = '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 .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 , Cool = 0)method index(Cool: |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) , Str(Cool) , Int(Cool) = .chars)multi method rindex(Str(Cool) : Str(Cool) , Int(Cool) = .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: , *)
Coerces the invocant to Str 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 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)
Coerces the invocant to IO::Path.
.say for '.'.IO.dir; # gives a directory listing