TITLE

Human readable form for comparison operators.
X<|Reference,Less>X<|Reference,Same>X<|Reference,More>


SUBTITLE

enum Order (:Less(-1), :Same(0), :More(1));


head

C<cmp> will first try to compare operands as strings (via coercion to L<C<Stringy>|/type/Stringy>), and, failing that, will try to compare numerically via the C«<=>» operator or any other type-appropriate comparison operator. See also L<the documentation for the C<cmp> operator|/routine/cmp#(Operators)_infix_cmp>.


multi infix:«<=>»(Int:D \a, Int:D \b --> Order:D)


root

Human readable form for comparison 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

enum Order


Consists of two parts, a I<key> and a I<value>. C<Pair>s can be seen as the
atomic units in L<C<Hash>|/type/Hash>es, and they are also used in conjunction with named
arguments and parameters.


Pair.new('key', 'value'); # The canonical way
'key' => 'value';         # this...
:key<value>;              # ...means the same as this
:key<value1 value2>;      # But this is  key => <value1 value2>
:foo(127);                # short for  foo => 127
:127foo;                  # the same   foo => 127


Note that last form supports Non-ASCII numerics as well:


# use MATHEMATICAL DOUBLE-STRUCK DIGIT THREE
say (:𝟛math-three);         # OUTPUT: «math-three => 3␤»


But not I<synthetic> (i.e. formed by a digit and additional Unicode marks):


code

You can also use an I<identifier-like literal> as key; this will not need the
quotes as long as it follows the syntax of
L<ordinary identifiers|/language/syntax#Ordinary_identifiers>:


(foo => 127)              # the same   foo => 127


:key;                     # same as   key => True
:!key;                    # same as   key => False


And this other variant, to be used in routine invocation


=begin code
sub colon-pair( :$key-value ) {
    say $key-value;
}
my $key-value = 'value';
colon-pair( :$key-value );               # OUTPUT: «value␤»
colon-pair( key-value => $key-value );   # OUTPUT: «value␤»
=end code


X<|Language,colon list (Pair)>
Colon pairs can be chained without a comma to create a List of Pairs. Depending
on context you may have to be explicit when assigning colon lists.


sub s(*%h){ say %h.raku };
s :a1:b2;
# OUTPUT: «{:a1, :b2}␤»


my $manna = :a1:b2:c3;
say $manna.^name;
# OUTPUT: «Pair␤»


$manna = (:a1:b2:c3);
say $manna.^name;
# OUTPUT: «List␤»


Any variable can be turned into a C<Pair> of its name and its value.


my $bar = 10;
my $p   = :$bar;
say $p; # OUTPUT: «bar => 10␤»


It is worth noting that when assigning a L<C<Scalar>|/type/Scalar> as value of a
C<Pair> the value holds the container of the value itself. This means that it is
possible to change the value from outside of the C<Pair> itself:


=begin code
my $v = 'value A';
my $pair = a => $v;
$pair.say;  # OUTPUT: «a => value A␤»

$v = 'value B';
$pair.say;  # OUTPUT: «a => value B␤»
=end code


Please also note that this behavior is totally unrelated to the way used to
build the C<Pair> itself (i.e., explicit usage of C<new>, use of colon, fat
arrow), as well as if the C<Pair> is bound to a variable.


It is possible to change the above behavior forcing the C<Pair> to remove the
scalar container and to hold the effective value itself via the method
L<freeze|/type/Pair#method_freeze>:


=begin code
my $v = 'value B';
my $pair = a => $v;
$pair.freeze;
$v = 'value C';
$pair.say; # OUTPUT: «a => value B␤»
=end code


As Pair implements L<C<Associative>|/type/Associative> role, its value can be
accessed using Associative subscription operator, however, due to Pair's
singular nature, the pair's value will be only returned for the pair's key.
L<C<Nil>|/type/Nil> object will be returned for any other key. Subscript
adverbs such as C<:exists> can be used on Pair.


multi method new(Pair: Mu  $key, Mu  $value)
multi method new(Pair: Mu :$key, Mu :$value)


multi method ACCEPTS(Pair:D $: %topic)
multi method ACCEPTS(Pair:D $: Pair:D $topic)
multi method ACCEPTS(Pair:D $: Mu $topic)


If C<%topic> is an L<C<Associative>|/type/Associative>, looks up the value using invocant's key in
it and checks invocant's value C<.ACCEPTS> that value:


say %(:42a) ~~ :42a; # OUTPUT: «True␤»
say %(:42a) ~~ :10a; # OUTPUT: «False␤»


If C<$topic> is another C<Pair>, checks the invocant's key and value
C<.ACCEPTS> the C<$topic>'s key and value respectively:


say :42a ~~ :42a; # OUTPUT: «True␤»
say :42z ~~ :42a; # OUTPUT: «False␤»
say :10a ~~ :42a; # OUTPUT: «False␤»


If C<$topic> is any other value, the invocant C<Pair>'s key is treated as a method name.
This method is called on C<$topic>, the L«C<Bool>|/type/Bool» result of which is compared
against the invocant C<Pair>'s L«C<Bool>|/type/Bool» value. For example, primality can
be tested using smartmatch:


say 3 ~~ :is-prime;             # OUTPUT: «True␤»
say 3 ~~  is-prime => 'truthy'; # OUTPUT: «True␤»
say 4 ~~ :is-prime;             # OUTPUT: «False␤»


This form can also be used to check
L<C<Bool>|/type/Bool> values of multiple methods on the same object, such as
L<C<IO::Path>|/type/IO::Path>, by using L<C<Junction>|/type/Junction>s:


say "foo" .IO ~~ :f & :rw; # OUTPUT: «False␤»
say "/tmp".IO ~~ :!f;      # OUTPUT: «True␤»
say "."   .IO ~~ :f | :d;  # OUTPUT: «True␤»


Returns a new C<Pair> object with key and value exchanged.


my $p = (d => 'Raku').antipair;
say $p.key;         # OUTPUT: «Raku␤»
say $p.value;       # OUTPUT: «d␤»


Sequence of itemized values


class Array


Immutable collection of distinct objects with integer weights


class Bag


Mutable collection of distinct objects with integer weights


class BagHash


Argument list suitable for passing to a Signature


class Capture


Mapping from strings to itemized values


class Hash


Low level storage of positional values


class IterationBuffer


Sequence of values


class List


Immutable mapping from strings to values


class Map


Immutable collection of distinct objects with Real weights


class Mix


Mutable collection of distinct objects with Real weights


class MixHash


Codepoint string in Normal Form C (composed)


class NFC


Codepoint string in Normal Form D (decomposed)


class NFD


Codepoint string in Normal Form KC (compatibility composed)


class NFKC


Codepoint string in Normal Form KD (compatibility decomposed)


class NFKD


Stash type for pseudo-packages


class PseudoStash


Interval of ordered values


class Range


An iterable, potentially lazy sequence of values


class Seq


Immutable collection of distinct objects


class Set


Mutable collection of distinct objects


class SetHash


A kind of List that automatically flattens into an outer container


class Slip


Table for "our"-scoped symbols


class Stash


A string of Unicode codepoints


class Uni


Mutable uint8 buffer for utf8 binary data


class utf8


Key/value pair


class Pair


Objects of type C<ObjAt> are the return value of C<.WHICH> calls on other
objects, and identify an object uniquely.


If two objects compare equally via C<===>, their C<.WHICH> methods return
the same ObjAt object.


See also L<C<ValueObjAt>|/type/ValueObjAt> for value types.


multi infix:<eqv>(ObjAt:D $a, ObjAt:D $b)


Returns True if the two ObjAt are the same, that is, if the object they identify
is the same.


my @foo = [2,3,1];
my @bar := @foo;
say @foo.WHICH eqv @bar.WHICH; # OUTPUT: «True␤»


enum Order

Operators

infix cmp

infix `<=>`

Operators

infix cmp

infix <=>

infix `<=>`