See creating operators on how to define new operators.

Operator precedence§

The precedence and associativity of Raku operators determine the order of evaluation of operands in expressions.

Where two operators with a different precedence act on the same operand, the subexpression involving the higher-precedence operator is evaluated first. For instance, in the expression 1 + 2 * 3, both the binary + operator for addition and the binary * operator for multiplication act on the operand 2. Because the * operator has a higher precedence than the + operator, the subexpression 2 * 3 will be evaluated first. Consequently, the resulting value of the overall expression is 7 and not 9.

Instead of "precedence" one can also speak of "binding": operators with a higher precedence are then said to have a tighter binding to the operand(s) in question, while operators with a lower precedence are said to have a looser binding. In practice one may also encounter blends of terminology, such as statements that an operator has a tighter or looser precedence.

The following table summarizes the precedence levels offered by Raku, listing them in order from high to low precedence. For each precedence level the table also indicates the associativity (discussed more below) of the operators assigned to that level and lists some example operators at that precedence level.

Notes:

• for the precedence levels marked with ¹, there are no operator subroutines with that precedence level (usually because the operators at that precedence level are special-cased by the compiler). This means that you cannot access that precedence level when setting the precedence of custom operators.

• =² denotes item assignment while =³ denotes list assignment operator.

Operator associativity§

Where two operators with a same precedence level act on an operand, the associativity of the operators determines which subexpression/operator is evaluated first. For instance, in the expression 100 / 2 * 10, the binary division operator / and the binary multiplication operator * have equal precedence, so that the order of their evaluation is determined by their associativity. As the two operators are left associative, operations are grouped from the left like this: (100 / 2) * 10. The expression thus evaluates to 500. Conversely, if / and * had both been right associative, the expression would have been grouped as 100 / (2 * 10) and would have evaluated to 5.

The following table shows how each associativity affects the interpretation of an expression involving three such operators of equal precedence and the same associativity (using a fictitious infix § operator):

Although this table only depicts infix operators, associativity also determines the order of evaluation for expressions with other types of operators. For example, if you created an infix § operator with the precedence equiv(&prefix:<~>), then the order of evaluation of ~$a § $b would depend on what associativity you assigned to §. If § is left associative, then ~$a will be evaluated first and then passed to §; if § is right associative, then $a § $b will be evaluated first and passed to ~.

When two operators have the same precedence but different associativity, determining the grouping of operands is more complicated. However, for operators built in to Raku, all operators with the same precedence level also have the same associativity.

Setting the associativity of non-infix operators is not yet implemented.

In the operator descriptions below, a default associativity of left is assumed.

Operator classification§

Operators can occur in several positions relative to a term:

Each operator (except method operators) is also available as a subroutine. The name of the routine is formed from the operator category, followed by a colon, then a list quote construct with the symbol(s) that make up the operator:

infix:<+>(1, 2);                # same as 1 + 2 
circumfix:«[ ]»(<a b c>);       # same as [<a b c>]

As a special case, a listop (list operator) can stand either as a term or as a prefix. Subroutine calls are the most common listops. Other cases include metareduced infix operators ([+] 1, 2, 3) and the listop ... etc. stub operators.

Defining custom operators is covered in Defining operators functions.

Substitution operators§

Each substitution operator comes into two main forms: a lowercase one (e.g., s///) that performs in-place (i.e., destructive behavior; and an uppercase form (e.g., S///) that provides a non-destructive behavior.

s/// in-place substitution§

my $str = 'old string';
$str ~~ s/o .+ d/new/;
say $str; # OUTPUT: «new string␤»

s/// operates on the $_ topical variable, changing it in place. It uses the given Regex to find portions to replace and changes them to the provided replacement string. Sets $/ to the Match object or, if multiple matches were made, a List of Match objects. Returns $/.

It's common to use this operator with the ~~ smartmatch operator, as it aliases left-hand side to $_, which s/// uses.

Regex captures can be referenced in the replacement part; it takes the same adverbs as the .subst method, which go between the s and the opening /, separated with optional whitespace:

my $str = 'foo muCKed into the lEn';
 
# replace second 'o' with 'x' 
$str ~~ s:2nd/o/x/;
 
# replace 'M' or 'L' followed by non-whitespace stuff with 'd' 
# and lowercased version of that stuff: 
$str ~~ s :g :i/<[ML]> (\S+)/d{lc $0}/;
 
say $str; # OUTPUT: «fox ducked into the den␤»

You can also use a different delimiter:

my $str = 'foober';
$str ~~ s!foo!fox!;
$str ~~ s{b(.)r} = " d$0n";
say $str; # OUTPUT: «fox den␤»

Non-paired characters can simply replace the original slashes. Paired characters, like curly braces, are used only on the match portion, with the substitution given by assignment (of anything: a string, a routine call, etc.).

S/// non-destructive substitution§

say S/o .+ d/new/ with 'old string';      # OUTPUT: «new string␤» 
S:g/« (.)/$0.uc()/.say for <foo bar ber>; # OUTPUT: «Foo␤Bar␤Ber␤»

S/// uses the same semantics as the s/// operator, except it leaves the original string intact and returns the resultant string instead of $/ ($/ still being set to the same values as with s///).

Note: since the result is obtained as a return value, using this operator with the ~~ smartmatch operator is a mistake and will issue a warning. To execute the substitution on a variable that isn't the $_ this operator uses, alias it to $_ with given, with, or any other way. Alternatively, use the .subst method.

tr/// in-place transliteration§

my $str = 'old string';
$str ~~ tr/dol/wne/;
say $str; # OUTPUT: «new string␤»

tr/// operates on the $_ topical variable and changes it in place. It behaves similar to Str.trans called with a single Pair argument, where key is the matching part (characters dol in the example above) and value is the replacement part (characters wne in the example above). Accepts the same adverbs as Str.trans. Returns the StrDistance object that measures the distance between original value and the resultant string.

my $str = 'old string';
$str ~~ tr:c:d/dol st//;
say $str; # OUTPUT: «old st␤»

TR/// non-destructive transliteration§

with 'old string' {
    say TR/dol/wne/; # OUTPUT: «new string␤» 
}

TR/// behaves the same as the tr/// operator, except that it leaves the $_ value untouched and instead returns the resultant string.

say TR:d/dol // with 'old string'; # OUTPUT: «string␤»

Assignment operators§

Raku has a variety of assignment operators, which can be roughly classified as simple assignment operators and compound assignment operators.

The simple assignment operator symbol is =. It is 'overloaded' in the sense that it can mean either item assignment or list assignment depending on the context in which it is used:

my $x = 1;        # item assignment; $x = 1 
my @x = 1,2,3;    # list assignment; @x = [1,2,3]

See the section on item and list assignment for a more elaborate and comparative discussion of these two types of assignment.

The compound assignment operators are metaoperators: they combine the simple assignment operator = with an infix operator to form a new operator that performs the operation specified by the infix operator before assigning the result to the left operand. Some examples of built-in compound assignment operators are +=, -=, *=, /=, min=, and ~=. Here is how they work:

my $a = 32;
$a += 10;         # $a = 42 
$a -= 2;          # $a = 40 
 
$a = 3;
$a min= 5;        # $a = 3 
$a min= 2;        # $a = 2 
 
my $s = 'a';
$s ~= 'b';        # $s = 'ab' 
 
# And an example of a custom operator: 
sub infix:<space-concat> ($a, $b) { $a ~ " " ~ $b };
$a = 'word1';
$a space-concat= 'word2';                 # OUTPUT: «'word1 word2'␤»

One thing the simple and compound assignment operators have in common is that they form so-called assignment expressions that return or evaluate to the assigned value:

my sub fac (Int $n) { [*] 1..$n };        # sub for calculating factorial 
my @x = ( my $y = fac(100), $y*101 );     # @x = [100!, 101!] 
 
my $i = 0;
repeat { say $i } while ($i += 1) < 10;   # OUTPUT: «0,1,2,...9␤»

In the first example, the assignment expression my $y = fac(100) declares $y, assigns the value fac(100) to it, and finally returns the assigned value fac(100). The returned value is then taken into account for constructing the List. In the second example the compound-assignment expression $i += 1 assigns the value $i + 1 to $i, and subsequently evaluates to the assigned value $i+1, thus allowing the returned value to be used for judging the while loop condition.

In dealing with simple and compound assignment operators, it is tempting to think that for instance the following two statements are (always) equivalent:

expression1 += expression2;                     # compound assignment
expression1  = expression1 + expression2;       # simple assignment

They are not, however, for two reasons. Firstly, expression1 in the compound assignment statement is evaluated only once, whereas expression1 in the simple assignment statement is evaluated twice. Secondly, the compound assignment statement may, depending on the infix operator in question, implicitly initialize expression1 if it is a variable with an undefined value. Such initialization will not occur for expression1 in the simple assignment statement.

The aforementioned two differences between the simple and compound assignment statements are briefly elucidated below.

The first difference is common amongst programming languages and mostly self-explanatory. In the compound assignment, there is only one expression1 that is explicitly specified to serve both as a term of the addition to be performed and as the location where the result of the addition, the sum, is to be stored. There is thus no need to evaluate it twice. The simple assignment, in contrast, is more generic in the sense that the value of the expression1 that serves as a term of the addition need not necessarily be the same as the value of the expression1 that defines the location where the sum must be stored. The two expressions are therefore evaluated separately. The distinction is particularly relevant in cases where the evaluation of expression1 has side effects in the form of changes to one or more variables:

my @arr = [10, 20, 30];
my $i = 0;
 
if rand < 1/2 {
    @arr[++$i] += 1;                # @arr = [10,21,30] 
} else {
    @arr[++$i] = @arr[++$i] + 1;    # @arr = [10,31,30] (or [10,20,21]?) 
}                                   # the result may be implementation-specific 
say @arr;

The second difference pointed out above is related to the widespread practice of using compound assignment operators in accumulator patterns. Such patterns involve a so-called accumulator: a variable that calculates the sum or a product of a series of values in a loop. To obviate the need for explicit accumulator initialization, Raku's compound assignment operators silently take care of the initialization where this is sensibly possible:

my @str = "Cleanliness is next to godliness".comb;
my ($len, $str);
for @str -> $c {
  $len += 1;
  $str ~= $c;
}
say "The string '$str' has $len characters.";

In this example the accumulators $len and $str are implicitly initialized to 0 and "", respectively, which illustrates that the initialization value is operator-specific. In this regard it is also noted that not all compound assignment operators can sensibly initialize an undefined left-hand side variable. The /= operator, for instance, will not arbitrarily select a value for the dividend; instead, it will throw an exception.

Although not strictly operators, methods can be used in the same fashion as compound assignment operators:

my $a = 3.14;
$a .= round;      # $a = $a.round; OUTPUT: «3»

Metaoperators§

Metaoperators can be parameterized with other operators or subroutines in the same way as functions can take other functions as parameters. To use a subroutine as a parameter, prefix its name with an &. Raku will generate the actual combined operator in the background, allowing the mechanism to be applied to user defined operators. To disambiguate chained metaoperators, enclose the inner operator in square brackets. There are quite a few metaoperators with different semantics as explained, next.

Negated relational operators§

The result of a relational operator returning Bool can be negated by prefixing with !. To avoid visual confusion with the !! operator, you may not modify any operator already beginning with !.

There are shortcuts for !== and !eq, namely != and ne.

my $a = True;
say so $a != True;    # OUTPUT: «False␤» 
my $i = 10;
 
my $release = Date.new(:2015year, :12month, :24day);
my $today = Date.today;
say so $release !before $today;     # OUTPUT: «False␤»

Reversed operators§

Any infix operator may be called with its two arguments reversed by prefixing with R. Associativity of operands is reversed as well.

say 4 R/ 12;               # OUTPUT: «3␤» 
say [R/] 2, 4, 16;         # OUTPUT: «2␤» 
say [RZ~] <1 2 3>,<4 5 6>  # OUTPUT: «(41 52 63)␤»

Hyper operators§

Hyper operators include « and », with their ASCII variants << and >>. They apply a given operator enclosed (or preceded or followed, in the case of unary operators) by « and/or » to one or two lists, returning the resulting list, with the pointy part of « or » aimed at the shorter list. Single elements are turned to a list, so they can be used too. If one of the lists is shorter than the other, the operator will cycle over the shorter list until all elements of the longer list are processed.

say (1, 2, 3) »*» 2;          # OUTPUT: «(2 4 6)␤» 
say (1, 2, 3, 4) »~» <a b>;   # OUTPUT: «(1a 2b 3a 4b)␤» 
say (1, 2, 3) »+« (4, 5, 6);  # OUTPUT: «(5 7 9)␤» 
say (&sin, &cos, &sqrt)».(0.5);
# OUTPUT: «(0.479425538604203 0.877582561890373 0.707106781186548)␤»

The last example illustrates how postcircumfix operators (in this case .()) can also be hypered.

my @a = <1 2 3>;
my @b = <4 5 6>;
say (@a,@b)»[1]; # OUTPUT: «(2 5)␤»

In this case, it's the postcircumfix[] which is being hypered.

Assignment metaoperators can be hyped.

my @a = 1, 2, 3;
say @a »+=» 1;    # OUTPUT: «[2 3 4]␤» 
my ($a, $b, $c);
(($a, $b), $c) «=» ((1, 2), 3);
say "$a, $c";       #  OUTPUT: «1, 3␤»

Hyper forms of unary operators have the pointy bit aimed at the operator and the blunt end at the list to be operated on.

my @wisdom = True, False, True;
say !« @wisdom;     # OUTPUT: «[False True False]␤» 
 
my @a = 1, 2, 3;
@a»++;
say @a;             # OUTPUT: «[2 3 4]␤»

Hyper operators are defined recursively on nested arrays.

say -« [[1, 2], 3]; # OUTPUT: «[[-1 -2] -3]␤»

Also, methods can be called in an out of order, concurrent fashion. The resulting list will be in order. Note that all hyper operators are candidates for parallelism and will cause tears if the methods have side effects. The optimizer has full reign over hyper operators, which is the reason that they cannot be defined by the user.

class CarefulClass { method take-care {} }
my CarefulClass @objs;
my @results = @objs».take-care();
 
my @slops;        # May Contain Nuts 
@slops».?this-method-may-not-exist();

Hyper operators can work with hashes. The pointy direction indicates if missing keys are to be ignored in the resulting hash. The enclosed operator operates on all values that have keys in both hashes.

my %outer = 1, 2, 3 Z=> <a b c>;
my %inner = 1, 2 Z=> <x z>;
say %outer «~» %inner;          # OUTPUT: «{"1" => "ax", "2" => "bz"}␤»

Hyper operators can take user-defined operators as their operator argument.

sub pretty-file-size (Int $size --> Str) {
    # rounding version of infix:</>(Int, Int) 
    sub infix:<r/>(Int \i1, Int \i2) {
        round(i1 / i2, 0.1)
    }
 
    # we build a vector of fractions of $size and zip that with the fitting prefix 
    for $size «[r/]« (2**60, 2**50, 2**40, 2**30, 2**20, 2**10)
              Z      <EB     PB     TB     GB     MB     KB> -> [\v,\suffix] {
        # starting with the biggest suffix, 
        # we take the first that is 0.5 of that suffix or bigger 
        return v ~ ' ' ~ suffix if v > 0.4
    }
    # this be smaller or equal then 0.4 KB 
    return $size.Str;
}
 
for 60, 50, 40, 30, 20, 10 -> $test {
    my &a = { (2 ** $test) * (1/4, 1/2, 1, 10, 100).pick * (1..10).pick };
    print pretty-file-size(a.Int) xx 2, ' ';
}
 
# OUTPUT: «10 EB 4 EB 2 PB 5 PB 0.5 PB 4 TB 300 GB 4.5 GB 50 MB 200 MB 9 KB 0.6 MB␤»

Whether hyperoperators descend into child lists depends on the nodality of the inner operator of a chain. For the hyper method call operator (».), the nodality of the target method is significant.

say (<a b>, <c d e>)».elems;        # OUTPUT: «(2 3)␤» 
say (<a b>, <c d e>)».&{ .elems };  # OUTPUT: «((1 1) (1 1 1))␤»

You can chain hyper operators to destructure a List of Lists.

my $neighbors = ((-1, 0), (0, -1), (0, 1), (1, 0));
my $p = (2, 3);
say $neighbors »>>+<<» ($p, *);   # OUTPUT: «((1 3) (2 2) (2 4) (3 3))␤»

Reduction metaoperators§

The reduction metaoperator, [ ], reduces a list with the given infix operator. It gives the same result as the reduce routine - see there for details.

# These two are equivalent: 
say [+] 1, 2, 3;                # OUTPUT: «6␤» 
say reduce &infix:<+>, 1, 2, 3; # OUTPUT: «6␤»

No whitespace is allowed between the square brackets and the operator. To wrap a function instead of an operator, provide an additional layer of square brackets:

sub plus { $^a + $^b };
say [[&plus]] 1, 2, 3;          # OUTPUT: «6␤»

The argument list is iterated without flattening. This means that you can pass a nested list to the reducing form of a list infix operator:

say [X~] (1, 2), <a b>;         # OUTPUT: «(1a 1b 2a 2b)␤»

which is equivalent to 1, 2 X~ <a b>.

By default, only the final result of the reduction is returned. Prefix the wrapped operator with a \, to return a lazy list of all intermediate values instead. This is called a "triangular reduce". If the non-meta part contains a \ already, quote it with [] (e.g. [\[\x]]).

my @n = [\~] 1..*;
say @n[^5];         # OUTPUT: «(1 12 123 1234 12345)␤»

Cross metaoperators§

The cross metaoperator, X, will apply a given infix operator in order of cross product to all lists, such that the rightmost operand varies most quickly.

1..3 X~ <a b> # OUTPUT: «<1a, 1b, 2a, 2b, 3a, 3b>␤»

Zip metaoperator§

The zip metaoperator (which is not the same thing as Z) will apply a given infix operator to pairs taken one left, one right, from its arguments. The resulting list is returned.

my @l = <a b c> Z~ 1, 2, 3;     # OUTPUT: «[a1 b2 c3]␤»

If one of the operands runs out of elements prematurely, the zip operator will stop. An infinite list can be used to repeat elements. A list with a final element of * will repeat its 2nd last element indefinitely.

my @l = <a b c d> Z~ ':' xx *;  # OUTPUT: «<a: b: c: d:>» 
   @l = <a b c d> Z~ 1, 2, *;   # OUTPUT: «<a1 b2 c2 d2>»

If an infix operator is not given, the , (comma operator) will be used by default:

my @l = 1 Z 2;  # OUTPUT: «[(1 2)]»

Sequential operators§

The sequential metaoperator, S, will suppress any concurrency or reordering done by the optimizer. Most simple infix operators are supported.

say so 1 S& 2 S& 3;  # OUTPUT: «True␤»

Nesting of metaoperators§

To avoid ambiguity when chaining metaoperators, use square brackets to help the compiler understand you.

my @a = 1, 2, 3;
my @b = 5, 6, 7;
@a X[+=] @b;
say @a;         # OUTPUT: «[19 20 21]␤»

Term precedence§

term < >§

The quote-words construct breaks up the contents on whitespace and returns a List of the words. If a word looks like a number literal or a Pair literal, it's converted to the appropriate number.

say <a b c>[1];   # OUTPUT: «b␤»

term ( )§

The grouping operator.

An empty group () creates an empty list. Parentheses around non-empty expressions simply structure the expression, but do not have additional semantics.

In an argument list, putting parenthesis around an argument prevents it from being interpreted as a named argument.

multi p(:$a!) { say 'named'      }
multi p($a)   { say 'positional' }
p a => 1;           # OUTPUT: «named␤» 
p (a => 1);         # OUTPUT: «positional␤»

term { }§

Block or Hash constructor.

If the content is empty, or contains a single list that starts with a Pair literal or %-sigiled variable, and the $_ variable or placeholder parameters are not used, the constructor returns a Hash. Otherwise it constructs a Block.

To force construction of a Block, follow the opening brace with a semicolon. To always ensure you end up with a Hash, you can use %( ) coercer or hash routine instead:

{}.^name.say;        # OUTPUT: «Hash␤» 
{;}.^name.say;       # OUTPUT: «Block␤» 
 
{:$_}.^name.say;     # OUTPUT: «Block␤» 
%(:$_).^name.say;    # OUTPUT: «Hash␤» 
hash(:$_).^name.say; # OUTPUT: «Hash␤»

circumfix [ ]§

The Array constructor returns an itemized Array that does not flatten in list context. Check this:

say .raku for [3,2,[1,0]]; # OUTPUT: «3␤2␤$[1, 0]␤»

This array is itemized, in the sense that every element constitutes an item, as shown by the $ preceding the last element of the array, the (list) item contextualizer.

Terms§

Terms have their own extended documentation.

Method postfix precedence§

postcircumfix [ ]§

sub postcircumfix:<[ ]>(@container, **@index,
                        :$k, :$v, :$kv, :$p, :$exists, :$delete)

Universal interface for positional access to zero or more elements of @container, a.k.a. "array indexing operator".

my @alphabet = 'a' .. 'z';
say @alphabet[0];                   # OUTPUT: «a␤» 
say @alphabet[1];                   # OUTPUT: «b␤» 
say @alphabet[*-1];                 # OUTPUT: «z␤» 
say @alphabet[100]:exists;          # OUTPUT: «False␤» 
say @alphabet[17, 0, 10, 20].join;  # OUTPUT: «raku␤» 
say @alphabet[23 .. *].raku;        # OUTPUT: «("x", "y", "z")␤» 
 
@alphabet[1, 2] = "B", "C";
say @alphabet[0..3].raku;           # OUTPUT: «("a", "B", "C", "d")␤»

See Subscripts, for a more detailed explanation of this operator's behavior and for how to implement support for it in custom types.

postcircumfix { }§

sub postcircumfix:<{ }>(%container, **@key,
                        :$k, :$v, :$kv, :$p, :$exists, :$delete)

Universal interface for associative access to zero or more elements of a %container, a.k.a. "hash indexing operator".

my %color = kiwi => "green", banana => "yellow", cherry => "red";
say %color{"banana"};                 # OUTPUT: «yellow␤» 
say %color{"cherry", "kiwi"}.raku;    # OUTPUT: «("red", "green")␤» 
say %color{"strawberry"}:exists;      # OUTPUT: «False␤» 
 
%color{"banana", "lime"} = "yellowish", "green";
%color{"cherry"}:delete; # note that value is always returned but removal only happens when delete is true. 
say %color;             # OUTPUT: «banana => yellowish, kiwi => green, lime => green␤»

See postcircumfix < > and postcircumfix « » for convenient shortcuts, and Subscripts for a more detailed explanation of this operator's behavior and how to implement support for it in custom types.

postcircumfix <>§

Decontainerization operator, which extracts the value from a container and makes it independent of the container type.

use JSON::Tiny;
 
my $config = from-json('{ "files": 3, "path": "/home/some-user/raku.rakudoc" }');
say $config.raku;      # OUTPUT: «${:files(3), :path("/home/some-user/raku.rakudoc")}␤» 
my %config-hash = $config<>;
say %config-hash.raku; # OUTPUT: «{:files(3), :path("/home/some-user/raku.rakudoc")}␤» 

It's a Hash in both cases, and it can be used like that; however, in the first case it was in item context, and in the second case it has been extracted to its proper context.

postcircumfix < >§

Shortcut for postcircumfix { } that quotes its argument using the same rules as the quote-words operator of the same name.

my %color = kiwi => "green", banana => "yellow", cherry => "red";
say %color<banana>;               # OUTPUT: «yellow␤» 
say %color<cherry kiwi>.raku;     # OUTPUT: «("red", "green")␤» 
say %color<strawberry>:exists;    # OUTPUT: «False␤»

Technically, not a real operator; it's syntactic sugar that's turned into the { } postcircumfix operator at compile-time.

postcircumfix « »§

Shortcut for postcircumfix { } that quotes its argument using the same rules as the interpolating quote-words operator of the same name.

my %color = kiwi => "green", banana => "yellow", cherry => "red";
my $fruit = "kiwi";
say %color«cherry "$fruit"».raku;   # OUTPUT: «("red", "green")␤»

Technically, not a real operator; it's syntactic sugar that's turned into the { } postcircumfix operator at compile-time.

postcircumfix ( )§

The call operator treats the invocant as a Callable and invokes it, using the expression between the parentheses as arguments.

Note that an identifier followed by a pair of parentheses is always parsed as a subroutine call.

If you want your objects to respond to the call operator, implement a method CALL-ME.

methodop .§

The operator for calling one method, $invocant.method.

Technically, not a real operator; it's syntax special-cased in the compiler.

methodop .&§

The operator to call a Callable, such as a Block, a Method, or a Sub with method syntax. The invocant will be bound to the first positional argument (and thus dispatch will fail if the Callable does not accept at least one positional argument).

Technically, not a real operator; it's syntax special-cased in the compiler.

my sub f($invocant){ "The arg has a value of $invocant" }
42.&f;
# OUTPUT: «The arg has a value of 42␤» 
 
42.&(-> $invocant { "The arg has a value of $invocant" });
# OUTPUT: «The arg has a value of 42␤»

methodop .=§

A mutating method call. $invocant.=method desugars to $invocant = $invocant.method, similar to = (item assignment) .

Technically, not a real operator; it's syntax special-cased in the compiler.

methodop .^§

A metamethod call. $invocant.^method calls method on $invocant's metaclass. It desugars to $invocant.HOW.method($invocant, ...). See the metaobject protocol documentation for more information.

Technically, not a real operator; it's syntax special-cased in the compiler. It can be also applied, within classes, to access metamethods on self:

class Foo {
    has $.a = 3;
    method bar {
        return $.^name
    }
};
say Foo.new.bar; # OUTPUT: «Foo␤» 

methodop .?§

Safe call operator. $invocant.?method calls method method on $invocant if it has a method of such name. Otherwise it returns Nil.

Technically, not a real operator; it's syntax special-cased in the compiler.

methodop .+§

$foo.+meth walks the MRO and calls all the methods called meth and submethods called meth if the type is the same as type of $foo. Those methods might be multis, in which case the matching candidate would be called.

After that, a List of the results are returned. If no such method was found, it throws an X::Method::NotFound exception.

class A {
  method foo { say "from A"; }
}
class B is A {
  multi method foo { say "from B"; }
  multi method foo(Str) { say "from B (Str)"; }
}
class C is B is A {
  multi method foo { say "from C"; }
  multi method foo(Str) { say "from C (Str)"; }
}
 
say C.+foo; # OUTPUT: «from C␤from B␤from A␤(True True True)␤»

methodop .*§

$foo.*meth walks the MRO and calls all the methods called meth and submethods called meth if the type is the same as type of $foo. Those methods might be multis, in which case the matching candidate would be called.

After that, a List of the results are returned. If no such method was found, an empty List is returned.

Technically, postfix .+ calls .* at first. Read postfix .+ section to see examples.

methodop ». / methodop >>.§

This is the hyper method call operator. Will call a method on all elements of a List out of order and return the list of return values in order.

my @a = <a b c>;
my @b = @a».ord;                  # OUTPUT: «[97, 98, 99]␤» 
# The first parameter of a method is the invocant. 
sub foo(Str:D $c){ $c.ord * 2 };
# So we can pretend to have a method call with a sub that got a good 
# first positional argument. 
say @a».&foo;
# Blocks have an implicit positional arguments that lands in $_. The latter can 
# be omitted for method calls. 
say @a».&{ .ord};

Hyper method calls may appear to be the same as doing a map call, however along with being a hint to the compiler that it can parallelize the call, the behavior is also affected by nodality of the method being invoked, depending on which either nodemap or deepmap semantics are used to perform the call.

The nodality is checked by looking up whether the Callable provides nodal method. If the hyper is applied to a method, that Callable is that method name, looked up on List type; if the hyper is applied to a routine (e.g. ».&foo), that routine functions as that Callable. If the Callable is determined to provide nodal method, nodemap semantics are used to perform the hyper call, otherwise duckmap semantics are used.

Take care to avoid a common mistake of expecting side-effects to occur in order. The following say is not guaranteed to produce the output in order:

@a».say;  # WRONG! Could produce a␤b␤c␤ or c␤b␤a␤ or any other order 

methodop .postfix / .postcircumfix§

In most cases, a dot may be placed before a postfix or postcircumfix:

my @a;
@a[1, 2, 3];
@a.[1, 2, 3]; # Same

This can be useful for visual clarity or brevity. For example, if an object's attribute is a function, putting a pair of parentheses after the attribute name will become part of the method call. So, either two pairs of parentheses must be used or a dot has to come before the parentheses to separate it from the method call.

class Operation {
    has $.symbol;
    has &.function;
}
my $addition = Operation.new(:symbol<+>, :function{ $^a + $^b });
say $addition.function()(1, 2);   # OUTPUT: «3␤» 
# OR 
say $addition.function.(1, 2);    # OUTPUT: «3␤»

If the postfix is an identifier, however, it will be interpreted as a normal method call.

1.i # No such method 'i' for invocant of type 'Int' 

Technically, not a real operator; it's syntax special-cased in the compiler.

methodop .:<prefix operator>§

An operator in prefix form can still be called like a method, that is, using the . methodop notation, by preceding it by a colon. For example:

my $a = 1;
say ++$a;       # OUTPUT: «2␤» 
say $a.:<++>;   # OUTPUT: «3␤»

Technically, not a real operator; it's syntax special-cased in the compiler, that is why it's classified as a methodop.

methodop .::§

A class-qualified method call, used to call a method as defined in a parent class or role, even after it has been redefined in the child class.

class Bar {
    method baz { 42 }
}
class Foo is Bar {
    method baz { "nope" }
}
say Foo.Bar::baz;       # OUTPUT: «42␤»

postfix ,=§

Creates an object that concatenates, in a class-dependent way, the contents of the variable on the left hand side and the expression on the right hand side:

my %a = :11a, :22b;
%a ,= :33x;
say %a # OUTPUT: «{a => 11, b => 22, x => 33}␤»

Autoincrement precedence§

++§

multi prefix:<++>($x is rw) is assoc<non>

Increments its argument by one and returns the updated value.

my $x = 3;
say ++$x;   # OUTPUT: «4␤» 
say $x;     # OUTPUT: «4␤»

It works by calling the succ method (for successor) on its argument, which gives custom types the freedom to implement their own increment semantics.

--§

multi prefix:<-->($x is rw) is assoc<non>

Decrements its argument by one and returns the updated value.

my $x = 3;
say --$x;   # OUTPUT: «2␤» 
say $x;     # OUTPUT: «2␤»

It works by calling the pred method (for predecessor) on its argument, which gives custom types the freedom to implement their own decrement semantics.

++§

multi postfix:<++>($x is rw) is assoc<non>

Increments its argument by one and returns the original value.

my $x = 3;
say $x++;   # OUTPUT: «3␤» 
say $x;     # OUTPUT: «4␤»

It works by calling the succ method (for successor) on its argument, which gives custom types the freedom to implement their own increment semantics; when undefined, it sets the value to 1 and returns it.

my $x;
$x++;
say $x;     # OUTPUT: «1␤»

Note that this does not necessarily return its argument; e.g., for undefined values, it returns 0:

my $x;
say $x++;   # OUTPUT: «0␤» 
say $x;     # OUTPUT: «1␤»

Increment on Str will increment the number part of a string and assign the resulting string to the container. An is rw container is required.

my $filename = "somefile-001.txt";
say $filename++ for 1..3;
# OUTPUT: «somefile-001.txt␤somefile-002.txt␤somefile-003.txt␤»

This will act on any Unicode numeral:

my $was٧ = "ثمانية٧";
$was٧++;
say $was٧; # OUTPUT: «ثمانية٨␤» 

Including, since version 6.d, Thai numerals

my $เลขไทย="๙๙";
$เลขไทย++;
say $เลขไทย; # OUTPUT: «๑๐๐␤» 

--§

multi postfix:<-->($x is rw) is assoc<non>

Decrements its argument by one and returns the original value.

my $x = 3;
say $x--;   # OUTPUT: «3␤» 
say $x;     # OUTPUT: «2␤»

It works by calling the pred method (for predecessor) on its argument, which gives custom types the freedom to implement their own decrement semantics.

Note that this does not necessarily return its argument;e.g., for undefined values, it returns 0:

my $x;
say $x--;   # OUTPUT: «0␤» 
say $x;     # OUTPUT: «-1␤»

Decrement on Str will decrement the number part of a string and assign the resulting string to the container. An is rw container is required. Crossing 0 is prohibited and throws X::AdHoc.

my $filename = "somefile-003.txt";
say $filename-- for 1..3;
# OUTPUT: «somefile-003.txt␤somefile-002.txt␤somefile-001.txt␤»

Exponentiation precedence§

infix **§

multi infix:<**>(Any, Any --> Numeric:D) is assoc<right>

The exponentiation operator coerces both arguments to Numeric and calculates the left-hand-side raised to the power of the right-hand side.

If the right-hand side is a non-negative integer and the left-hand side is an arbitrary precision type (Int, FatRat), then the calculation is carried out without loss of precision.

Unicode superscripts will behave in exactly the same way.

sub squared( Int $num ) { $num² };
say squared($_) for ^5; # OUTPUT: «0␤1␤4␤9␤16␤»

It also works for sequences of several Unicode superscript numbers:

sub twenty-second-power( Int $num ) { $num²² };
say twenty-second-power($_) for ^5; # OUTPUT: «0␤1␤4194304␤31381059609␤17592186044416␤»

Symbolic unary precedence§

prefix ?§

multi prefix:<?>(Mu --> Bool:D)

Boolean context operator.

Coerces the argument to Bool by calling the Bool method on it. Note that this collapses Junctions.

prefix !§

multi prefix:<!>(Mu --> Bool:D)

Negated Boolean context operator.

Coerces the argument to Bool by calling the Bool method on it, and returns the negation of the result. Note that this collapses Junctions.