TITLE

SUBTITLE

head

In an expression like C<1 + 2 * 3>, the C<2 * 3> is evaluated first.


Metaoperators can be parameterized with other operators or subroutines.


multi sub infix:<..>($a, $b --> Range:D) is assoc<non>


X<Range operator>: Constructs a L<Range|/type/Range> from the arguments.


# vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6


root

operators


para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

Operators


Powerful cache


What are contexts and how to get into them


A context is needed, in many occasions, to interpret the value of a container.
In Raku, we will use context to coerce the value of a container into some type
or class, or decide what to do with it, as in the case of the sink context.


I<Sink> is equivalent to C<void> context, that is, a context in which we throw
(down the sink, as it were) the result of an operation or the return value from
a block. In general, this context will be invoked in warnings and errors when a
statement does not know what to do with that value.


code

=begin code
my $sub = -> $a { return $a² };
$sub; # OUTPUT: «WARNINGS:␤Useless use of $sub in sink context (line 1)␤»
=end code


X<|sinking> You can force that sink context on L<Iterator>s, by using the
L<C<sink-all>|/routine/sink-all> method. L<Proc>s can also be
L<sunk via the C<sink> method|https://docs.raku.org/type/Proc#method_sink>,
forcing them to raise an exception and not returning anything.


In general, blocks will warn if evaluated in sink context; however,
L<gather/take blocks|/language/control#Flow%29_gather_take> are explicitly
evaluated in sink context, with values returned explicitly using C<take>.


In sink context, an object will call its C<sink> method if present:


=begin code
sub foo {
    return [<a b c>] does role {
        method sink { say "sink called" }
    }
}
foo
# OUTPUT: sink called
=end code


This context, and probably all of them except sink above, are I<conversion> or I<interpretation> contexts in the sense that they take an untyped or typed variable and duck-type it to whatever is needed to perform the operation. In some cases that will imply a conversion (from L<Str> to L<Numeric>, for instance); in other cases simply an interpretation (L<IntStr> will be interpreted as L<Int> or as L<Str>).


I<Number context> is called whenever we need to apply a numerical operation on a
variable.


=begin code
my $not-a-string="1                 ";
my $neither-a-string="3                        ";
say $not-a-string+$neither-a-string; # OUTPUT: «4␤»
=end code


In the code above, strings will be interpreted in numeric context as long as
there is only some numbers and no other characters. It can have any number of
leading or trailing whitespace, however.


Numeric context can be forced by using arithmetic operators such as C<+> or
C<->. In that context, the L<C<Numeric>|/routine/Numeric> method will be called
if available and the value returned used as the numeric value of the object.


=begin code
my $t = True;
my $f = False;
say $t+$f;      # OUTPUT: «1␤»
say $t.Numeric; # OUTPUT: «1␤»
say $f.Numeric; # OUTPUT: «0␤»
my $list= <a b c>;
say True+$list; # OUTPUT: «4␤»
=end code


In the case of I<listy> things, the numeric value will be in general equivalent
to C<.elems>; in some cases, like L<Thread|/Numeric#(Thread)_method_Numeric> it
will return an unique thread identifier.


In a I<string context>, values can be manipulated as strings. This context is
used, for instance, for coercing non-string values so that they can be printed
to standard output.


Or when smartmatching to a regular expression:


say 333444777 ~~ /(3+)/; # OUTPUT: «｢333｣␤ 0 => ｢333｣␤»


In general, the L<C<Str> routine|/routine/Str> will be called on a variable to
contextualize it; since this method is inherited from L<Mu>, it is always
present, but it is not always guaranteed to work. In some core classes it will
issue a warning.


L<C<~>|/routine/~> is the (unary) string contextualizer. As an operator, it
concatenates strings, but as a prefix operator it becomes the string context
operator.


=begin code
my @array = [ [1,2,3], [4,5,6]];
say ~@array; # OUTPUT: «1 2 3 4 5 6␤»
=end code


This will happen also in a
L<I<reduction>|https://docs.raku.org/language/operators#Reduction_operators>
context, when C<[~]> is applied to a list


say [~] [ 3, 5+6i, Set(<a b c>), [1,2,3] ]; # OUTPUT: «35+6ic a b1 2 3␤»


In that sense, empty lists or other containers will stringify to an empty
string:


Since L<C<~> acts also as buffer concatenation operator|https://docs.raku.org/routine/~#(Operators)_infix_~>,
using it will
have to check that every element is not empty, since a single empty buffer in
string context will behave as a string, thus yielding an error.


say [~] Buf.new(0x3,0x33), Buf.new(0x2,0x22);
# OUTPUT: «Buf:0x<03 33 02 22>␤»


=begin code :skip-test<Stringification error>
my $non-empty = Buf.new(0x3, 0x33);
my $empty = [];
my $non-empty-also = Buf.new(0x2,0x22);
say [~] $non-empty, $empty, $non-empty-also;
# OUTPUT: «(exit code 1) Cannot use a Buf as a string, but you called the Stringy method on it
# in block <unit> at /tmp/bO_heb6AS9 line 1␤␤»
=end code


Since C<~> is putting in string context the second element of this list,
L<C<~>|https://docs.raku.org/routine/~#(Operators)_infix_~> is going to be
using the second form that applies to strings, thus yielding the shown error.
Simply making sure that everything you concatenate is a buffer will avoid this
problem.


my $non-empty = Buf.new(0x3, 0x33);
my $empty = Buf.new();
my $non-empty-also = Buf.new(0x2,0x22);
say [~] $non-empty, $empty, $non-empty-also; # OUTPUT: «Buf:0x<03 33 02 22>␤»


In general, a context will coerce a variable to a particular type by calling the
contextualizer; in the case of mixins, if the context class is mixed in, it will
behave in that way.


my $described-number = 1i but 'Unity in complex plane';
say $described-number; # OUTPUT: «Unity in complex plane␤»


C<but> creates a mixin, which endows the complex number with a C<Str> method.
C<say> puts into string context, that is, it calls C<Str>, the string
contextualizer, with the result shown above.


Contexts and contextualizers


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Operators

Operator precedence

Metaoperators

Infix operators

infix `..`

Pod::From::Cache v0.4.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation