Operators

Common Perl 6 infixes, prefixes, postfixes, and more!

See Sub on how to define operators.

Operator Precedence

In an expression like 1 + 2 * 3, the 2 * 3 is evaluated first because the infix * has tighter precedence than the +.

The following table summarizes the precedence levels in Perl 6, from tightest to loosest:

A Level Examples
N Terms 42 3.14 "eek" qq["foo"] $x :!verbose @$array
L Method postfix .meth .+ .? .* .() .[] .{} .<> .«» .:: .= .^ .:
N Autoincrement ++ --
R Exponentiation **
L Symbolic unary ! + - ~ ? | || +^ ~^ ?^ ^
L Dotty infix .= .
L Multiplicative * / % %% +& +< +> ~& ~< ~> ?& div mod gcd lcm
L Additive + - +| +^ ~| ~^ ?| ?^
L Replication x xx
X Concatenation ~
X Junctive and &
X Junctive or | ^
L Named unary temp let
N Structural infix but does <=> leg cmp .. ..^ ^.. ^..^
C Chaining infix != == < <= > >= eq ne lt le gt ge ~~ === eqv !eqv =~=
X Tight and &&
X Tight or || ^^ // min max
R Conditional ?? !! ff fff
R Item assignment = => += -= **= xx=
L Loose unary so not
X Comma operator , :
X List infix Z minmax X X~ X* Xeqv ...
R List prefix print push say die map substr ... [+] [*] any Z=
X Loose and and andthen
X Loose or or xor orelse
X Sequencer <==, ==>, <<==, ==>>
N Terminator ; {...}, unless, extra ), ], }

Using two ! symbols below generically to represent any pair of operators that have the same precedence, the associativities specified above for binary operators are interpreted as follows:

A Assoc Meaning of $a ! $b ! $c
L left ($a ! $b) ! $c
R right $a ! ($b ! $c)
N non ILLEGAL
C chain ($a ! $b) and ($b ! $c)
X list infix:<!>($a; $b; $c)

For unary operators this is interpreted as:

A Assoc Meaning of !$a!
L left (!$a)!
R right !($a!)
N non ILLEGAL

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

Operator classification

Operators can occur in several positions relative to a term:

+term prefix
term1 + term2 infix
term++ postfix
(term) circumfix
term1[term2] postcircumfix

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

infix:<+>(12);                # 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 meta-reduced infix operators ([+] 1, 2, 3) and the prefix ... etc. stub operators.

Defining custom operators is covered in Defining Operators functions.

Meta Operators

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

Substitution Operators

s/// in-place substitution

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

Operates on $_ topical variable, changing it in place. 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. 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 lower-cased 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 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/.+ d/new/ with 'old string';      # OUTPUT: «new string␤» 
S:g/« (.)/$0.uc()/.say for <foo bar ber># OUTPUT: «Foo␤Bar␤Ber␤» 

Same semantics as the s/// operator, except 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.

Assignment Operators

Infix operators can be combined with the assignment operator to modify a value and apply the result to a container in one go. Containers will be autovivified if possible. Some examples:

my $a = 32;
$a += 10;     # 42 
$a -= 2;      # 40 
 
$a = 3;
$a min= 5;    # still 3 
$a min= 2;    # 2 
 
my $s = 'a';
$s ~= 'b';    # 'ab' 

This behavior is automatically extended to include custom-defined infix operators.

sub infix:<space-concat> ($a$b{ $a ~ " " ~ $b };
my $a = 'word1';
$a space-concat= 'word2';     # RESULT: «'word1 word2'» 

Although not strictly operators, methods can be used in the same fashion.

my Real $a = 1/2;
$a = 3.14;
$a .= round;      # RESULT: «3» 

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/2416;  # OUTPUT: «2␤» 

Hyper Operators

Hyper operators apply a given operator enclosed by « and » to one or two lists, returning the resulting list. The pointy part of « or » has to point to the shorter list. A list with just one element is fine too. If one of the lists is shorter then the other, the operator will cycle over the shorter list until all elements of the longer list are processed.

say (123) »*» 2;          # OUTPUT: «(2 4 6)␤» 
say (1234) »~» <a b>;   # OUTPUT: «(1a 2b 3a 4b)␤» 
say (123) »+« (456);  # OUTPUT: «(5 7 9)␤» 

Assignment meta operators can be hyped.

my @a = 123;
say @a »+=» 1;    # OUTPUT: «[2 3 4]␤» 

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

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

Hyper operators are defined recursively on nested arrays.

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

Also, methods can be called in an out of order, concurrent fashion. The resulting list is in order. Note that all hyper operators are candidates for autothreading 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.

%foo «+» %bar; intersection of keys
%foo »+« %bar; union of keys
%outer »+» %inner; only keys of %inner that exist in %outer will occur in the result
my %outer = 123 Z=> <a b c>;
my %inner = 12 Z=> <x z>;
say %outer «~» %inner;          # OUTPUT: «{"1" => "ax", "2" => "bz"}␤» 

Hyper operators can take user defined operators as its operator argument.

sub pretty-file-site (Int $size --> Str{
    # rounding version of infix:</>(Int, Int) 
    sub infix:<r/>(Int \i1Int \i2{
        round(i1 / i20.1)
    }
 
    # we build a vector of fractions of $size and zip that with the fitting prefix 
    for $size «[r/]« (2**602**502**402**302**202**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 605040302010 -> $test {
    my &a = { (2 ** $test* (1/41/2110100).pick * (1..10).pick };
    print pretty-file-site(a.Intxx 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 = ((-10), (0-1), (01), (10));
my $p = (23);
say $neighbors »>>+<<» ($p*);   # OUTPUT: «((1 3) (2 2) (2 4) (3 3))␤» 

Reduction Operators

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 [+123;                # OUTPUT: «6␤» 
say reduce &infix:<+>123# OUTPUT: «6␤» 

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

sub plus { $^a + $^b };
say [[&plus]] 123;          # 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~] (12), <a b>;         # OUTPUT: «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 Operators

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

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

Zip Operators

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~ 123;     # RESULT: «[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 *;  # RESULT: «<a: b: c: d:>» 
   @l = <a b c d> Z~ 12*;   # RESULT: «<a1 b2 c2 d2>» 

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

my @l = 1 Z 2;  # RESULT: «[(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 Meta Operators

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

my @a = 123;
my @b = 567;
@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 sub p(:$a!{ say 'named'      }
multi sub p($a)   { say 'positional' }
p => 1;           # OUTPUT: «named␤» 
p (=> 1);         # OUTPUT: «positional␤» 

term { }

Block or Hash constructor.

If the content looks like a list of pairs and does not use $_ or other placeholder parameters, the constructor returns an itemized Hash.

Otherwise it constructs a Block.

Note that this construct does not re-parse the contents; rather, the contents are always parsed as a statement list (i.e. like a block), and if the later analysis shows that it needs to be interpreted as a hash, the block is executed and coerced to Hash.

circumfix [ ]

The Array constructor returns an itemized Array which does not flatten in list context.

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 a @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[1541711].join;  # OUTPUT: «perl␤» 
say @alphabet[23 .. *].perl;        # OUTPUT: «("x", "y", "z")␤» 
 
@alphabet[12= "B""C";
say @alphabet[0..3].perl            # OUTPUT: «("a", "B", "C", "d")␤» 

See Subscripts, for a more detailed explanation of this operator's behavior, and 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"}.perl;    # OUTPUT: «("red", "green")␤» 
say %color{"strawberry"}:exists;      # OUTPUT: «False␤» 
 
%color{"banana""lime"} = "yellowish""green";
%color{"cherry"}:delete;
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 < >

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>.perl;     # OUTPUT: «("red", "green")␤» 
say %color<strawberry>:exists;    # OUTPUT: «False␤» 

This is not a real operator, just syntactic sugar that is 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».perl;   # OUTPUT: «("red", "green")␤» 

This is not a real operator, just syntactic sugar that is 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, you need to implement a method CALL-ME.

postfix .

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

Technically this is not an operator, but syntax special-cased in the compiler.

postfix .&

The operator to call a subroutine (with at least one positional argument) like a method. The invocant will be bound to the first positional argument.

Technically this is not an operator, but syntax special-cased in the compiler.

my sub f($invocant){ dd $invocant}
my $i = 42;
42.&f;
# OUTPUT: «Int $invocant = 42␤» 
42.&(-> $invocant { dd $invocant });
# OUTPUT: «Int $invocant = 42␤» 

postfix .=

A mutating method call. $invocant.=method desugars to $invocant = $invocant.method, similar to =.

Technically this is not an operator, but syntax special-cased in the compiler.

postfix .^

A meta-method call. $invocant.^method calls method on $invocant's metaclass. It desugars to $invocant.HOW.method($invocant, ...). See HOW for more information.

Technically this is not an operator, but syntax special-cased in the compiler.

postfix .?

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

Technically this is not an operator, but syntax special-cased in the compiler.

postfix .+

$invocant.+method calls all methods called method from $invocant, and returns a List of the results. Dies if no such method was found.

Technically this is not an operator, but syntax special-cased in the compiler.

postfix .*

$invocant.*method calls all methods called method from $invocant, and returns a List of the results. If no such method was found, an empty List is returned.

Technically this is not an operator, but syntax special-cased in the compiler.

postfix ». / postfix >>.

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]␤» 
sub foo(Str:D $c){ $c.ord * 2 };  # The first parameter of a method is the invocant. 
say @a».&foo;                     # So we can pretend to have a method call with a sub that got a good first positional argument. 
say @a».&{ .ord};                 # Blocks have an implicit positional arguments that lands in $_. The latter can be omitted for method calls. 

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 

postfix .postfix / .postcircumfix

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

my @a;
@a[123];
@a.[123]; # 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()(12);   # OUTPUT: «3␤» 
# OR 
say $addition.function.(12);    # 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 this is not an operator, but syntax special-cased in the compiler.

postfix .:<prefix>

A prefix can be called like a method using colonpair notation. For example:

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

Technically this is not an operator, but syntax special-cased in the compiler.

postfix .::

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

Autoincrement Precedence

prefix ++

multi sub prefix:<++>($x is rwis 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.

prefix --

multi sub prefix:<-->($x is rwis 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.

postfix ++

multi sub postfix:<++>($x is rwis 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.

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

postfix --

multi sub postfix:<-->($x is rwis 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. A 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 sub infix:<**>(AnyAny --> Numeric:Dis 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.

Symbolic Unary Precedence

prefix ?

multi sub 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 sub 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.

prefix +

multi sub prefix:<+>(Any --> Numeric:D)

Numeric context operator.

Coerces the argument to Numeric by calling the Numeric method on it.

prefix -

multi sub prefix:<->(Any --> Numeric:D)

Negative numeric context operator.

Coerces the argument to Numeric by calling the Numeric method on it, and then negates the result.

prefix ~

multi sub prefix:<~>(Any --> Str:D)

String context operator.

Coerces the argument to Str by calling the Str method on it.

prefix |

Flattens objects of type Capture, Pair, List, Map and Hash into an argument list.

Outside of argument lists, it returns a Slip, which makes it flatten into the outer list. Inside argument list Positionals are turned into positional arguments and Associatives are turned into named arguments.

prefix ||

TODO

prefix +^

multi sub prefix:<+^>(Any --> Int:D)

Integer bitwise negation operator.

Coerces the argument to Int and does a bitwise negation on the result, assuming two's complement.

prefix ~^

Coerces the argument to a non-variable-encoding string buffer type (e.g. buf8, buf16, buf32) and then flips each bit in that buffer.

Please note that this has not yet been implemented.

prefix ?^

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

Boolean bitwise negation operator.

Coerces the argument to Bool and then does a bit flip, which makes it the same as prefix:<!> .

prefix ^

multi sub prefix:<^>(Any --> Range:D)

upto operator.

Coerces the argument to Numeric, and generates a range from 0 up to (but excluding) the argument.

say ^5;         # OUTPUT: «0..^5␤» 
for ^5 { }      # 5 iterations 

Dotty Infix Precedence

These operators are like their Method Postfix counterparts, but require surrounding whitespace (before and/or after) to distinguish them.

infix .=

Calls the right-side method on the value in the left-side container, replacing the resulting value in the left-side container.

In most cases this behaves identically to the postfix mutator, but the precedence is lower so:

    my $a = -5
    say ++$a.=abs
    # OUTPUT: «6␤» 
    say ++$a .= abs
    # OUTPUT: «Cannot modify an immutable Int␤ 
    #           in block <unit> at <tmp> line 1␤␤» 

infix .

Calls the following method (whose name must be alphabetic) on the left-side invocant.

Note that the infix form of the operator has a slightly lower precedence than postfix .meth.

say -5.abs;      # like: -(5.abs) 
# OUTPUT: «-5␤» 
say -5 . abs;    # like: (-5) . abs 
# OUTPUT: «5␤» 
say -5 .abs;     # following whitespace is optional 
# OUTPUT: «5␤» 

Multiplicative Precedence

infix *

multi sub infix:<*>(AnyAny --> Numeric:D)

Multiplication operator.

Coerces both arguments to Numeric and multiplies them. The result is of the wider type. See Numeric for details.

infix /

multi sub infix:</>(AnyAny --> Numeric:D)

Division operator.

Coerces both argument to Numeric and divides the left through the right number. Division of Int values returns Rat, otherwise the "wider type" rule described in Numeric holds.

infix div

multi sub infix:<div>(Int:DInt:D --> Int:D)

Integer division operator. Rounds down.

infix %

multi sub infix:<%>($x$y --> Numeric:D)

Modulo operator. Coerces to Numeric first.

Generally the following identity holds:

my ($x$y= 1,2;
$x % $y == $x - floor($x / $y* $y

infix %%

multi sub infix:<%%>($a$b --> Bool:D)

Divisibility operator. Returns True if $a % $b == 0.

infix mod

multi sub infix:<mod>(Int:D $aInt:D $b --> Int:D)

Integer modulo operator. Returns the remainder of an integer modulo operation.

infix +&

multi sub infix:<+&>($a$b --> Int:D)

Numeric bitwise AND operator. Coerces both arguments to Int and does a bitwise AND operation assuming two's complement.

infix +<

multi sub infix:<< +< >>($a$b --> Int:D)

Integer bit shift to the left.

infix +>

multi sub infix:<< +> >>($a$b --> Int:D)

Integer bit shift to the right.

infix ~&

Coerces each argument to a non-variable-encoding string buffer type (e.g. buf8, buf16, buf32) and then performs a numeric bitwise AND on corresponding integers of the two buffers, padding the shorter buffer with zeroes.

infix ~<

Coerces the left argument to a non-variable-encoding string buffer type (e.g. buf8, buf16, buf32) and then performs a numeric bitwise left shift on the bits of the buffer.

Please note that this has not yet been implemented.

infix ~>

Coerces the left argument to a non-variable-encoding string buffer type (e.g. buf8, buf16, buf32) and then performs a numeric bitwise right shift on the bits of the buffer.

Please note that this has not yet been implemented.

infix gcd

multi sub infix:<gcd>($a$b --> Int:D)

Coerces both arguments to Int and returns the greatest common divisor.

infix lcm

multi sub infix:<lcm>($a$b --> Int:D)

Coerces both arguments to Int and returns the least common multiple, that is the smallest integer that is evenly divisible by both arguments.

Additive Precedence

infix +

multi sub infix:<+>($a$b --> Numeric:D)

Addition operator.

Coerces both arguments to Numeric and adds them.

infix -

multi sub infix:<->($a$b --> Numeric:D)

Subtraction operator.

Coerces both arguments to Numeric and subtracts the second from the first.

infix +|

multi sub infix:<+|>($a$b --> Int:D)

Integer bitwise OR operator.

Coerces both arguments to Int and does a bitwise OR (inclusive OR) operation.

infix +^

multi sub infix:<+^>($a$b --> Int:D)

Integer bitwise XOR operator.

Coerces both arguments to Int and does a bitwise XOR (exclusive OR) operation.

infix ~|

Coerces each argument to a non-variable-encoding string buffer type (e.g. buf8, buf16, buf32) and then performs a numeric bitwise OR on corresponding integers of the two buffers, padding the shorter buffer with zeroes.

infix ~^

Coerces each argument to a non-variable-encoding string buffer type (e.g. buf8, buf16, buf32) and then performs a numeric bitwise XOR on corresponding integers of the two buffers, padding the shorter buffer with zeroes.

infix ?|

multi sub infix:<?|>($a$b --> Bool:D)

Boolean logical OR operator.

Coerces both arguments to Bool and does a logical OR (inclusive OR) operation.

Replication Precedence

infix x

sub infix:<x>($a$b --> Str:D)

String repetition operator.

Repeats the string $a $b times, if necessary coercing $a to Str and $b Int. Returns an empty string if $b <= 0 .

say 'ab' x 3;           # OUTPUT: «ababab␤» 
say 42 x 3;             # OUTPUT: «424242␤» 
 
my $a = 'a'.IO;
my $b = 3.5;
say $a x $b;            # OUTPUT: «aaa␤» 

infix xx

multi sub infix:<xx>($a$b --> List:D)

List repetition operator.

Returns a list of $a repeated and evaluated $b times ($b is coerced to Int). If $b <= 0 , the empty list is returned.

The left-hand side is evaluated for each repetition, so

say [12xx 5;
# OUTPUT: «([1 2] [1 2] [1 2] [1 2] [1 2])␤» 

returns five distinct arrays (but with the same content each time), and

rand xx 3

returns three pseudo random numbers that are determined independently.

The right-hand side can be *, in which case a lazy, infinite list is returned.

Concatenation

infix ~

multi sub infix:<~>(Any,   Any)
multi sub infix:<~>(Str:DStr:D)
multi sub infix:<~>(Buf:DBuf:D)

String concatenation operator.

Coerces both arguments to Str and concatenates them. If both arguments are Buf, a combined buffer is returned.

say 'ab' ~ 'c';     # OUTPUT: «abc␤» 

Junctive AND (all) Precedence

infix &

multi sub infix:<&>($a$b --> Junction:Dis assoc<list>

All junction operator.

Creates an all Junction from its arguments. See Junction for more details.

Junctive OR (any) Precedence

infix |

multi sub infix:<|>($a$b --> Junction:Dis assoc<list>

Any junction operator.

Creates an any Junction from its arguments. See Junction for more details.

infix ^

multi sub infix:<^>($a$b --> Junction:Dis assoc<list>

One junction operator.

Creates a one Junction from its arguments. See Junction for more details.

Named Unary Precedence

prefix temp

sub prefix:<temp>(Mu $a is rw)

"temporizes" the variable passed as the argument. The variable begins with the same value as it had in the outer scope, but can be assigned new values in this scope. Upon exiting the scope, the variable will be restored to its original value.

my $a = "three";
say $a# OUTPUT: «three␤» 
{
    temp $a;
    say $a# OUTPUT: «three␤» 
    $a = "four";
    say $a# OUTPUT: «four␤» 
}
say $a# OUTPUT: «three␤» 

Note that you can also assign immediately as part of the call to temp:

temp $a = "five";

prefix let

sub prefix:<let>(Mu $a is rw)

Restores the previous value if the block exits unsuccessfully. A successful exit means the block returned a defined value or a list.

my $answer = 42;
 
{
    let $answer = 84;
    die if not Bool.pick;
    CATCH {
        default { say "it's been reset :(" }
    }
    say "we made it 84 sticks!";
}
 
say $answer;

In the above case, if the Bool.pick returns true, the answer will stay as 84 because the block returns a defined value (say returns true). Otherwise the die statement will cause the block to exit unsuccessfully, resetting the answer to 42.

Nonchaining Binary Precedence

infix does

sub infix:<does>(Mu $objMu $roleis assoc<non>

Mixes $role into $obj at run time. Requires $obj to be mutable.

$role doesn't need to a be a role, it can be something that knows how to act like a role; e.g., enum values.

If methods of the same name are present already, the last mixed in role takes precedence.

infix but

multi sub infix:<but>(Mu $obj1Mu   $roleis assoc<non>
multi sub infix:<but>(Mu $obj1Mu:D $obj2is assoc<non>

Creates a copy of $obj with $role mixed in. Since $obj is not modified, but can be used to created immutable values with mixins.

Instead of a role, you can provide an instantiated object. In this case, the operator will create a role for you automatically. The role will contain a single method named the same as $obj.^name and that returns $obj:

say 42 but 'forty two'# OUTPUT: «forty two␤» 
 
my $s = 12 but class Warbles { method hi { 'hello' } }.new;
say $s.Warbles.hi;    # OUTPUT: «hello␤» 
say $s + 42;          # OUTPUT: «54␤» 

If methods of the same name are present already, the last mixed in role takes precedence. A list of methods can be provided in parentheses separated by comma. In this case conflicts will be reported at runtime.

infix cmp

multi sub infix:<cmp>(Any,       Any)
multi sub infix:<cmp>(Real:D,    Real:D)
multi sub infix:<cmp>(Str:D,     Str:D)
multi sub infix:<cmp>(Version:DVersion:D)

Generic, "smart" three-way comparator.

Compares strings with string semantics, numbers with number semantics, Pair objects first by key and then by value etc.

if $a eqv $b, then $a cmp $b always returns Order::Same.

say (=> 3cmp (=> 4);   # OUTPUT: «Less␤» 
say 4        cmp 4.0;        # OUTPUT: «Same␤» 
say 'b'      cmp 'a';        # OUTPUT: «More␤» 

infix leg

multi sub infix:<leg>(Any,   Any)
multi sub infix:<leg>(Str:DStr:D)

String three-way comparator. Short for less, equal or greater?.

Coerces both arguments to Str, and then does a lexicographic comparison.

say 'a' leg 'b';       # OUTPUT: «Less␤» 
say 'a' leg 'a';       # OUTPUT: «Same␤» 
say 'b' leg 'a';       # OUTPUT: «More␤» 

infix <=>

multi sub infix:«<=>»($a$b --> Order:Dis assoc<non>

Numeric three-way comparator.

Coerces both arguments to Real, and then does a numeric comparison.

infix ..

multi sub infix:<..>($a$b --> Range:Dis assoc<non>

Range operator

Constructs a Range from the arguments.

infix ..^

multi sub infix:<..^>($a$b --> Range:Dis assoc<non>

Right-open range operator.

Constructs a Range from the arguments, excluding the end point.

infix ^..

multi sub infix:<^..>($a$b --> Range:Dis assoc<non>

Left-open range operator.

Constructs a Range from the arguments, excluding the start point.

infix ^..^

multi sub infix:<^..^>($a$b --> Range:Dis assoc<non>

Open range operator

Constructs a Range from the arguments, excluding both start and end point.

Chaining Binary Precedence

infix ==

multi sub infix:<==>(AnyAny)
multi sub infix:<==>(Int:DInt:D)
multi sub infix:<==>(Num:DNum:D)
multi sub infix:<==>(Rational:DRational:D)
multi sub infix:<==>(Real:DReal:D)
multi sub infix:<==>(Complex:DComplex:D)
multi sub infix:<==>(Numeric:DNumeric:D)

Numeric equality operator.

Coerces both arguments to Numeric if necessary, and returns True if they are equal.

infix !=

sub infix:<!=>(MuMu --> Bool:D)

Numeric inequality operator.

Coerces both arguments to Numeric (if necessary), and returns True if they are distinct.

infix

Numeric inequality operator.

Equivalent to !=, at codepoint U+2260 (NOT EQUAL TO).

infix <

multi sub infix:«<»(Int:DInt:D)
multi sub infix:«<»(Num:DNum:D)
multi sub infix:«<»(Real:DReal:D)

Numeric less than operator.

Coerces both arguments to Real (if necessary), and returns True if the first argument is smaller than the second.

infix <=

multi sub infix:«<=»(Int:DInt:D)
multi sub infix:«<=»(Num:DNum:D)
multi sub infix:«<=»(Real:DReal:D)

Numeric less than or equal to operator.

Coerces both arguments to Real (if necessary), and returns True if the first argument is smaller than or equal to the second.

infix

Numeric less than or equal to operator.

Equivalent to <=, at codepoint U+2264 (LESS-THAN OR EQUAL TO).

infix >

multi sub infix:«>»(Int:DInt:D)
multi sub infix:«>»(Num:DNum:D)
multi sub infix:«>»(Real:DReal:D)

Numeric greater than operator.

Coerces both arguments to Real (if necessary), and returns True if the first argument is larger than the second.

infix >=

multi sub infix:«>=»(Int:DInt:D)
multi sub infix:«>=»(Num:DNum:D)
multi sub infix:«>=»(Real:DReal:D)

Numeric greater than or equal to operator.

Coerces both arguments to Real (if necessary), and returns True if the first argument is larger than or equal to the second.

infix

Numeric greater than or equal to operator.

Equivalent to >=, at codepoint U+2265 (GREATER-THAN OR EQUAL TO).

infix eq

multi sub infix:<eq>(Any,   Any)
multi sub infix:<eq>(Str:DStr:D)

String equality operator.

Coerces both arguments to Str (if necessary), and returns True if both are equal.

Mnemonic: equal

infix ne

multi sub infix:<ne>(Mu,    Mu)
multi sub infix:<ne>(Str:DStr:D)

String inequality operator.

Coerces both arguments to Str (if necessary), and returns False if both are equal.

Mnemonic: not equal

infix gt

multi sub infix:<gt>(Mu,    Mu)
multi sub infix:<gt>(Str:DStr:D)

String greater than operator.

Coerces both arguments to Str (if necessary), and returns True if the first is larger than the second, as determined by lexicographic comparison.

Mnemonic: greater than

infix ge

multi sub infix:<ge>(Mu,    Mu)
multi sub infix:<ge>(Str:DStr:D)

String greater than or equal to operator.

Coerces both arguments to Str (if necessary), and returns True if the first is equal to or larger than the second, as determined by lexicographic comparison.

Mnemonic: greater or equal

infix lt

multi sub infix:<lt>(Mu,    Mu)
multi sub infix:<lt>(Str:DStr:D)

String less than operator.

Coerces both arguments to Str (if necessary), and returns True if the first is smaller than the second, as determined by lexicographic comparison.

Mnemonic: less than

infix le

multi sub infix:<le>(Mu,    Mu)
multi sub infix:<le>(Str:DStr:D)

String less than or equal to operator.

Coerces both arguments to Str (if necessary), and returns True if the first is equal to or smaller than the second, as determined by lexicographic comparison.

Mnemonic: less or equal

infix before

multi sub infix:<before>(Any,       Any)
multi sub infix:<before>(Real:D,    Real:D)
multi sub infix:<before>(Str:D,     Str:D)
multi sub infix:<before>(Version:DVersion:D)

Generic ordering, uses the same semantics as cmp. Returns True if the first argument is smaller than the second.

infix after

multi sub infix:<after>(Any,       Any)
multi sub infix:<after>(Real:D,    Real:D)
multi sub infix:<after>(Str:D,     Str:D)
multi sub infix:<after>(Version:DVersion:D)

Generic ordering, uses the same semantics as cmp. Returns True if the first argument is larger than the second.

infix eqv

sub infix:<eqv>(AnyAny)

Equivalence operator. Returns True if the two arguments are structurally the same, i.e. from the same type and (recursively) contain the same values.

say [123eqv [123];    # OUTPUT: «True␤» 
say Any eqv Any;                # OUTPUT: «True␤» 
say 1 eqv 2;                    # OUTPUT: «False␤» 
say 1 eqv 1.0;                  # OUTPUT: «False␤» 

The default eqv operator even works with arbitrary objects. E.g., eqv will consider two instances of the same object as being structurally equivalent:

my class A {
    has $.a;
}
say A.new(=> 5eqv A.new(=> 5);  # OUTPUT: «True␤» 

Although the above example works as intended the eqv code has to fall back to a slower code path in order to do its job. One way to avoid this is to implement an appropriate infix eqv operator:

my class A {
    has $.a;
}
multi infix:<eqv>(A $lA $r{ $l.a eqv $r.a }
say A.new(=> 5eqv A.new(=> 5);            # OUTPUT: «True␤» 

infix ===

sub infix:<===>(AnyAny)

Value identity operator. Returns True if both arguments are the same object.

my class A { };
my $a = A.new;
say $a === $a;              # OUTPUT: «True␤» 
say A.new === A.new;        # OUTPUT: «False␤» 
say A === A;                # OUTPUT: «True␤» 

For value types, === behaves like eqv:

say 'a' === 'a';            # OUTPUT: «True␤» 
say 'a' === 'b';            # OUTPUT: «False␤» 
 
# different types 
say 1 === 1.0;              # OUTPUT: «False␤» 

=== uses the WHICH method to obtain the object identity, so all value types must override method WHICH.

infix =:=

multi sub infix:<=:=>(Mu \aMu \b)

Container identity operator. Returns True if both arguments are bound to the same container. If it returns True, it generally means that modifying one will also modify the other.

my ($a$b= (13);
say $a =:= $b;      # OUTPUT: «False␤» 
$b = 2;
say $a;             # OUTPUT: «1␤» 
$b := $a;
say $a =:= $b;      # OUTPUT: «True␤» 
$a = 5;
say $b;             # OUTPUT: «5␤» 

infix ~~

The smart-match operator. Aliases the left-hand side to $_, then evaluates the right-hand side, and calls .ACCEPTS($_) on it. The semantics are left to the type of the right-hand side operand.

Here is an excerpt of built-in smart-matching functionality:

Right-hand side Comparison semantics
Mu:U type check
Str string equality
Numeric numeric equality
Regex regex match
Callable boolean result of invocation
Set/Bag equal element values
Any:D object identity

infix =~=

multi sub infix:<=~=>(AnyAny)
multi sub infix:<=~=>(Int:DInt:D)
multi sub infix:<=~=>(Num:DNum:D)
multi sub infix:<=~=>(Rational:DRational:D)
multi sub infix:<=~=>(Real:DReal:D)
multi sub infix:<=~=>(Complex:DComplex:D)
multi sub infix:<=~=>(Numeric:DNumeric:D)

The approximately-equal operator. Calculates the relative difference between the left-hand and right-hand sides and returns True if the difference is less than $*TOLERANCE (which defaults to 1e-15). However, if either side is zero then it checks that the absolute difference between the sides is less than $*TOLERANCE. Note that this operator is not arithmetically symmetrical (doesn't do ± Δ):

my $x = 1;
say ($x + $*TOLERANCE=~= $x;   # OUTPUT: «False␤» 
say ($x - $*TOLERANCE=~= $x;   # OUTPUT: «True␤» 

The tolerance is supposed to be modifiable via an adverb:

my ($x$y= 4242.1;
say $x =~= $y :tolerance(.1);

however, this is not yet implemented. The same effect can be achieved by assigning to $*TOLERANCE.

{
    my $*TOLERANCE = .1;
    say 11 =~= 10;        # OUTPUT: «True␤» 
}

Note that setting $*TOLERANCE = 0 will cause all comparisons to fail.

{
    my $*TOLERANCE = 0;
    say 1 =~= 1;          # OUTPUT: «False␤» 
}

Tight AND Precedence

infix &&

Returns the first argument that evaluates to False in boolean context, or otherwise the last argument.

Note that this short-circuits, i.e. if one of the arguments evaluates to a false value, the arguments to the right of are never evaluated.

sub a { 1 }
sub b { 0 }
sub c { die "never called" };
say a() && b() && c();      # OUTPUT: «0␤» 

Tight OR Precedence

infix ||

Returns the first argument that evaluates to True in boolean context, or otherwise the last argument.

Note that this short-circuits, i.e. if one of the arguments evaluates to a true value, the arguments to the right of are never evaluated.

sub a { 0 }
sub b { 1 }
sub c { die "never called" };
say a() || b() || c();      # OUTPUT: «1␤» 

infix ^^

Short-circuit exclusive-or. Returns the true argument if there is one (and only one). Returns the last argument if all arguments are false. Returns Nil otherwise (when more than one argument is true).

This operator short-circuits in the sense that it does not evaluate any arguments after a 2nd true result.

say 0 ^^ 42;                             # OUTPUT: «42␤» 
say '' ^^ 0;                             # OUTPUT: «0␤» 
say 0 ^^ 42 ^^ 1 ^^ die "never called";  # OUTPUT: «␤» 

Note that the semantics of this operator may not be what you assume: infix ^^ flips to first true value it finds, and then flips to Nil forever after the second, no matter how many more true values there are. (In other words, it has "find the one true value" semantics, not "boolean parity" semantics.)

infix //

Defined-or operator. Returns the first defined operand or else the last operand. Short-circuits.

say Any // 0 // 42;         # OUTPUT: «0␤» 

infix min

Returns the smallest of the arguments, as determined by cmp semantics.

my $foo = 42;
$foo min= 0   # read as: $foo decreases to 0 

infix max

Returns the largest of the arguments, as determined by cmp semantics.

my $foo = -42;
$foo max= 0   # read as: $foo increases to 0 

Conditional Operator Precedence

infix ?? !!

Ternary operator, conditional operator.

$condition ?? $true !! $false evaluates and returns the expression from the $true branch if $condition is a true value. Otherwise it evaluates and returns the $false branch.

infix ff

sub infix:<ff>(Mu $aMu $b)

Flipflop operator.

Compares both arguments to $_ (that is, $_ ~~ $a and $_ ~~ $b). Evaluates to False until the left-hand smartmatch is True, at which point it evaluates to True until the right-hand smartmatch is True.

In effect, the left-hand argument is the "start" condition, and the right-hand is the "stop" condition. This construct is typically used to pick up only a certain section of lines. For example:

my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
    This code block is what we're after.
    We'll use 'ff' to get it.
=end code
More unimportant text.
END

my @codelines = gather for $excerpt.lines {
    take $_ if "=begin code" ff "=end code"
}

# this will print four lines, starting with "=begin code" and ending with
# "=end code"
say @codelines.join("\n");

After matching the start condition, the operator will then match the same $_ to the stop condition, and act accordingly if successful. In this example, only the first element is printed:

for <AB C D B E F> {
    say $_ if /A/ ff /B/;  # OUTPUT: «AB␤» 
}

If you only want to test against a start condition, and have no stop condition, * can be used as the "stop" condition.

for <A B C D E> {
    say $_ if /C/ ff *;    # OUTPUT: «C␤D␤E␤» 
}

For the sed-like version, which does not try $_ on the stop condition after succeeding on the start condition, see fff.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix ^ff

sub infix:<^ff>(Mu $aMu $b)

Works like ff, except it does not return True for items matching the start condition (including items also matching the stop condition).

A comparison:

my @list = <A B C>;
say $_ if /A/ ff /C/ for @list;    # OUTPUT: «A␤B␤C␤» 
say $_ if /A/ ^ff /C/ for @list;   # OUTPUT: «B␤C␤» 

The sed-like version can be found in ^fff.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix ff^

sub infix:<ff^>(Mu $aMu $b)

Works like ff, except it does not return True for items matching the stop condition (including items that first matched the start condition).

my @list = <A B C>;
say $_ if /A/ ff /C/ for @list;    # OUTPUT: «A␤B␤C␤» 
say $_ if /A/ ff^ /C/ for @list;   # OUTPUT: «A␤B␤» 

The sed-like version can be found in fff^.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix ^ff^

sub infix:<^ff^>(Mu $aMu $b)

Works like ff, except it does not return True for items matching either the stop or start condition (or both).

my @list = <A B C>;
say $_ if /A/ ff /C/ for @list;    # OUTPUT: «A␤B␤C␤» 
say $_ if /A/ ^ff^ /C/ for @list;  # OUTPUT: «B␤» 

The sed-like version can be found in ^fff^.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix fff

sub infix:<fff>(Mu $aMu $b)

Performs a sed-like flipflop operation, wherein it returns False until the left argument smartmatches against $_, and after that returns True until the right argument smartmatches against $_.

Works similarly to ff, except that it only tries one argument per invocation. That is, if $_ smartmatches the left argument, fff will not then try to match that same $_ against the right argument.

for <AB C D B E F> {
    say $_ if /A/ fff /B/;         # OUTPUT: «AB␤C␤D␤B␤» 
}

The non-sed-like flipflop (which after successfully matching the left argument against $_ will try that same $_ against the right argument and act accordingly), see ff.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix ^fff

sub infix:<^fff>(Mu $aMu $b)

Like fff, except it does not return true for matches to the left argument.

my @list = <A B C>;
say $_ if /A/ fff /C/ for @list;   # OUTPUT: «A␤B␤C␤» 
say $_ if /A/ ^fff /C/ for @list;  # OUTPUT: «B␤C␤» 

For the non-sed version, see ^ff.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix fff^

sub infix:<fff^>(Mu $aMu $b)

Like fff, except it does not return true for matches to the right argument.

my @list = <A B C>;
say $_ if /A/ fff /C/ for @list;   # OUTPUT: «A␤B␤C␤» 
say $_ if /A/ fff^ /C/ for @list;  # OUTPUT: «A␤B␤» 

For the non-sed version, see ff^.

This operator cannot be overloaded, as it's handled specially by the compiler.

infix ^fff^

sub infix:<^fff^>(Mu $aMu $b)

Like fff, except it does not return true for matches to either the left or right argument.

my @list = <A B C>;
say $_ if /A/ fff /C/ for @list;   # OUTPUT: «A␤B␤C␤» 
say $_ if /A/ ^fff^ /C/ for @list# OUTPUT: «B␤» 

For the non-sed version, see ^ff^.

This operator cannot be overloaded, as it's handled specially by the compiler.

Item Assignment Precedence

infix =

sub infix:<=>(Mu $a is rwMu $b)

Item assignment operator.

Places the value of the right-hand side into the container on the left-hand side. Its exact semantics are left to the container type on the left-hand side.

(Note that item assignment and list assignment have different precedence levels, and the syntax of the left-hand side decides whether an equal sign = is parsed as item assignment or list assignment operator).

infix =>

sub infix:«=>»($keyMu $value --> Pair:D)

Pair constructor.

Constructs a Pair object with the left-hand side as the key and the right-hand side as the value.

Note that the => operator is syntactically special-cased, in that it allows unquoted identifier on the left-hand side.

my $p = => 1;
say $p.key;         # OUTPUT: «a␤» 
say $p.value;       # OUTPUT: «1␤» 

A Pair within an argument list with an unquoted identifier on the left is interpreted as a named argument.

See the Terms language documentation for more ways to create Pair objects.

Loose Unary Precedence

prefix not

multi sub prefix:<not>(Mu $x --> Bool:D)

Evaluates its argument in boolean context (and thus collapses Junctions), and negates the result. Please note that not is easy to misuse, see traps.

prefix so

multi sub prefix:<so>(Mu $x --> Bool:D)

Evaluates its argument in boolean context (and thus collapses Junctions), and returns the result.

Comma Operator Precedence

infix ,

sub infix:<,>(*@a --> List:Dis assoc<list>

Constructs a List from its arguments. Also used syntactically as the separator of arguments in calls.

infix :

Used as an argument separator just like infix , and marks the argument to its left as the invocant. That turns what would otherwise be a function call into a method call.

substr('abc': 1);       # same as 'abc'.substr(1) 

Infix : is only allowed after the first argument of a non-method call. In other positions it's a syntax error.

List Infix Precedence

infix Z

sub infix:<Z>(**@lists --> Seq:Dis assoc<chain>

Zip operator.

Interleaves the lists passed to Z like a zipper, stopping as soon as the first input list is exhausted. The returned Seq contains a nested list with values for all Z operators in a chain.

say (12 Z <a b c> Z <+ ->).perl;  # OUTPUT: «((1, "a", "+"), (2, "b", "-")).Seq␤» 
for <a b c> Z <1 2 3> -> [$l$r{
    say "$l:$r"
}
# OUTPUT: «a:1␤b:2␤c:3␤» 

The Z operator also exists as a meta operator, in which case the inner lists are replaced by the value from applying the operator to the list:

say 100200 Z+ 4223;             # OUTPUT: «(142 223)␤» 
say 1..3 Z~ <a b c> Z~ 'x' xx 3;    # OUTPUT: «(1ax 2bx 3cx)␤» 

infix X

sub infix:<X>(**@lists --> List:D)

Creates a cross product from all the lists, order so that the rightmost elements vary most rapidly:

1..3 X <a b c> X 9
# produces ((1 a 9) (1 b 9) (1 c 9) 
#           (2 a 9) (2 b 9) (2 c 9) 
#           (3 a 9) (3 b 9) (3 c 9)) 

The X operator also exists as a meta operator, in which case the inner lists are replaced by the value from applying the operator to the list:

1..3 X~ <a b c> X~ 9
# produces (1a9 1b9 1c9 2a9 2b9 2c9 3a9 3b9 3c9) 

infix ...

multi sub infix:<...>(**@) is assoc<list>
multi sub infix:<...^>(**@) is assoc<list>

The sequence operator is a generic operator to produce lazy lists.

It can have initial elements and a generator on left-hand side, and an endpoint on the right-hand side.

The sequence operator invokes the generator with as many arguments as necessary. The arguments are taken from the initial elements and the already generated elements.

The default generator is *.succ or *.pred, depending on how the end points compare:

say 1 ... 4;        # OUTPUT: «(1 2 3 4)␤» 
say 4 ... 1;        # OUTPUT: «(4 3 2 1)␤» 
say 'a' ... 'e';    # OUTPUT: «(a b c d e)␤» 
say 'e' ... 'a';    # OUTPUT: «(e d c b a)␤» 

An endpoint of * (Whatever) generates an infinite sequence, with a default generator of *.succ

say (1 ... *)[^5];  # OUTPUT: «(1 2 3 4 5)␤» 

Custom generators are the last argument before the '...' operator. This one takes two arguments, and generates the Fibonacci numbers

say (11-> $a$b { $a + $b } ... *)[^8];    # OUTPUT: «(1 1 2 3 5 8 13 21)␤» 
# same but shorter 
say (11*+* ... *)[^8];                      # OUTPUT: «(1 1 2 3 5 8 13 21)␤» 

Of course the generator can also take only one argument.

say 5{ $_ * 2 } ... 40;                       # OUTPUT: «5 10 20 40␤» 

There must be at least as many initial elements as arguments to the generator.

Without a generator, and more than one initial element, and all initial elements numeric, the sequence operator tries to deduce the generator. It knows about arithmetic and geometric sequences.

say 246 ... 12;     # OUTPUT: «(2 4 6 8 10 12)␤» 
say 124 ... 32;     # OUTPUT: «(1 2 4 8 16 32)␤» 

If the endpoint is not *, it's smart-matched against each generated element, and the sequence is terminated when the smart-match succeeded. For the ... operator, the final element is included, for the ...^ operator it's excluded.

This allows you to write

say 11*+* ...^ *>= 100;

To generate all Fibonacci numbers up to but excluding 100.

The ... operators consider the initial values as "generated elements" as well, so the are also checked against the endpoint:

my $end = 4;
say 124816 ... $end;
# OUTPUT: «(1 2 4)␤» 

List Prefix Precedence

infix =

List assignment operator. Its exact semantics are left to the container type on the left-hand side. See Array and Hash for common cases.

The distinction between item assignment and list assignment is determined by the parser depending on the syntax of the left-hand side.

infix :=

Binding operator. Whereas $x = $y puts the value in $y into $x, $x := $y makes $x and $y the same thing.

my $a = 42;
my $b = $a;
$b++;
say $a;

This will output 42, because $a and $b both contained the number 42, but the containers were different.

my $a = 42;
my $b := $a;
$b++;
say $a;

This will output 43, since $b and $a both represented the same object.

Please note that := is a compile time construct. As such it can not be referred to at runtime and thus can't be used as an argument to meta operators.

infix ::=

Read-only binding operator. See infix :=.

listop ...

The yada, yada, yada operator or stub operator. If it's the only statement in a routine or type, it marks that routine or type as a stub (which is significant in the context of pre-declaring types and composing roles).

If the ... statement is executed, it calls fail, with the default message stub code executed.

listop !!!

Fatal stub operator.

If it's the only statement in a routine or type, it marks that routine or type as a stub (which is significant in the context of pre-declaring types and composing roles).

If the !!! statement is executed, it calls die, with the default message stub code executed.

listop ???

Admonitory stub operator.

If it's the only statement in a routine or type, it marks that routine or type as a stub (which is significant in the context of pre-declaring types and composing roles).

If the ??? statement is executed, it calls warn, with the default message stub code executed.

Reduction operators

Any infix operator (except for non-associating operators) can be surrounded by square brackets in term position to create a list operator that reduces using that operation.

say [+123;      # 1 + 2 + 3 = 6 
my @a = (56);
say [*@a;           # 5 * 6 = 30 

Reduction operators have the same associativity as the operators they are based on.

say [-] 432;      # 4-3-2 = (4-3)-2 = -1 
say [**432;     # 4**3**2 = 4**(3**2) = 262144 

Loose AND precedence

infix and

Same as infix &&, except with looser precedence.

Returns the first operand that evaluates to False in boolean context, or otherwise the last operand, it short-circuits. Please note that and is easy to misuse, see traps.

infix andthen

Returns Empty upon encountering the first undefined argument, otherwise the last argument. Short-circuits. The result of the left side is bound to $_ for the right side, or passed as arguments if the right side is a Callable.

A handy use of this operator is to alias a routine's return value to $_ and to do additional manipulation with it, such as printing or returning it to caller. Since the andthen operator short-circuits, statements on the right-hand side won't get executed, unless left-hand side is defined.

sub load-data {
    rand  > .5 or return# simulated load data failure; return Nil 
    (rand > .3 ?? 'error' !! 'good data'xx 10 # our loaded data 
}
load-data.first: /good/ andthen say "$_ is good";
# OUTPUT: «(good data is good)␤» 
 
load-data() andthen .return# return loaded data, if it's defined 
die "Failed to load data!!";

The above example will print good data is good only if the subroutine returned any items that match /good/ and will die unless loading data returned defined value. The aliasing behaviour lets us pipe the values across the operator.

The andthen operator is a close relative of with statement modifier, and some compilers compile with to andthen, meaning these two lines have equivalent behaviour:

.say with 42;
42 andthen .say;

Loose OR Precedence

infix or

Same as infix ||, except with looser precedence.

Returns the first argument that evaluates to True in boolean context, or otherwise the last argument, it short-circuits. Please note that or is easy to misuse, see traps.

infix orelse

Similar to infix //. Returns the first defined argument, or else the last argument. Short-circuits. The result of the left side is bound to $_ for the right side, or passed as arguments if the right side is a Callable.

Sequencer Precedence

infix ==>

This feed operator takes the result from the left and passes it to the next (right) routine as the last parameter.

The precedence is very loose so you will need to use parentheses to assign the result or you can even just use another feed operator! In the case of routines/methods that take a single argument or where the first argument is a block, it's often required that you call with parentheses (though this is not required for the very last routine/method).

# Traditional structure, read bottom-to-top 
my @result =
    sort                # (4) Sort, result is <Earth People> 
    grep { /<[PE]>/ },  # (3) Look for P or E 
    map { .tc },        # (2) Capitalize the words 
    <people of earth>;  # (1) Start with the input 
 
# Feed (left-to-right) with parentheses, read top-to-bottom 
my @result = (
    <people of earth>   # (1) Start with the input 
    ==> map({ .tc })    # (2) Capitalize the words 
    ==> grep /<[PE]>/   # (3) Look for P or E 
    ==> sort            # (4) Sort, result is <Earth People> 
);
 
# For illustration, method chaining equivalent, read top-to-bottom 
my @result =
    <people of earth>   # (1) Start with the input 
    .map({ .tc })       # (2) Capitalize the words 
    .grep(/<[PE]>/)     # (3) Look for P or E 
    .sort;              # (4) Sort, result is <Earth People> 
 
# To assign without the need of parentheses use another feed operator 
my @result =
    <people of earth>
    ==> map({ .tc })
    ==> grep /<[PE]>/
    ==> sort()
    ==> @result;
 
# It can be useful to capture a partial result, however, unlike 
# the leftward feed operator, it does require parentheses or a semicolon 
my @result =
    <people of earth>
    ==> map({ .tc })
    ==> my @caps@caps   # also could wrap in parentheses instead 
    ==> grep /<[PE]>/
    ==> sort()
    ==> @result;

The feed operator lets you construct method-chaining-like patterns out of routines and the results of methods on unrelated data. In method-chaining, you are restricted to the methods available on the data or the result of previous method call. With feed operators, that restriction is gone. The resulting code could also be seen to be more readable than a series of method calls broken over multiple lines.

Note: In the future, this operator will see some change as it gains the ability to run list operations in parallel. It will enforce that the left operand is enclosable as a closure (that can be cloned and run in a subthread).

infix <==

This leftward feed operator takes the result from the right and passes it to the previous (left) routine as the last parameter. This elucidates the right-to-left dataflow for a series of list manipulating functions.

# Traditional structure, read bottom-to-top 
my @result =
    sort                   # (4) Sort, result is <Earth People> 
    grep { /<[PE]>/ },     # (3) Look for P or E 
    map { .tc },           # (2) Capitalize the words 
    <people of earth>;     # (1) Start with the input 
 
# Feed (right-to-left) with parentheses, read bottom-to-top 
my @result = (
    sort()                 # (4) Sort, result is <Earth People> 
    <== grep({ /<[PE]>/ }# (3) Look for P or E 
    <== map({ .tc })       # (2) Capitalize the words 
    <== <people of earth>  # (1) Start with the input 
);
 
# To assign without parentheses, use another feed operator 
my @result
    <== sort()              # (4) Sort, result is <Earth People> 
    <== grep({ /<[PE]>/ })  # (3) Look for P or E 
    <== map({ .tc })        # (2) Capitalize the words 
    <== <people of earth>;  # (1) Start with the input 
 
# It can be useful to capture a partial result 
my @result
    <== sort()
    <== grep({ /<[PE]>/ })
    <== my @caps            # unlike ==>there's no need for additional statement
    <== map({ .tc })
    <== <people of earth>;

Unlike the rightward feed operator, the result is not closely mappable to method-chaining. However, compared to the traditional structure above where each argument is separated by a line, the resulting code is more demonstrative than commas. The leftward feed operator also allows you to "break into" the statement and capture an intermediary result which can be extremely useful for debugging or to take that result and create another variation on the final result.

Note: In the future, this operator will see some change as it gains the ability to run list operations in parallel. It will enforce that the right operand is enclosable as a closure (that can be cloned and run in a subthread).