txt: ## operators.md
  ## Chunk 5 of 6
   "go to top of document")[§](#infix_^fff "direct link")
  
  ```raku
  sub infix:<^fff>(Mu $a, Mu $b)
  ```
  
  Like [fff](/routine/fff), except it does not return true for matches to the left argument.
  
  ```raku
  my @list = <X A B C Y>;
  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`](/routine/$CIRCUMFLEX_ACCENTff).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  ## [infix `fff^`](#Operators "go to top of document")[§](#infix_fff^ "direct link")
  
  ```raku
  sub infix:<fff^>(Mu $a, Mu $b)
  ```
  
  Like [fff](/routine/fff), except it does not return true for matches to the right argument.
  
  ```raku
  my @list = <X A B C Y>;
  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^](/routine/ff$CIRCUMFLEX_ACCENT).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  ## [infix `^fff^`](#Operators "go to top of document")[§](#infix_^fff^ "direct link")
  
  ```raku
  sub infix:<^fff^>(Mu $a, Mu $b)
  ```
  
  Like [fff](/routine/fff), except it does not return true for matches to either the left or right argument.
  
  ```raku
  my @list = <X A B C Y>;
  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^`](/routine/$CIRCUMFLEX_ACCENTff$CIRCUMFLEX_ACCENT).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  # [Item assignment precedence](#Operators "go to top of document")[§](#Item_assignment_precedence "direct link")
  
  ## [infix `=` (item assignment)](#Operators "go to top of document")[§](#infix_=_(item_assignment) "direct link")
  
  ```raku
  sub infix:<=>(Mu $a is rw, Mu $b)
  
  ```
  
  Called the *item assignment operator*. It copies the value of the right-hand side into the Scalar container on the left-hand side.
  
  The item assignment operator should be distinguished from the [list assignment operator](#infix_=_(list_assignment)), which uses the same operator symbol `=` but has a lower precedence. The context of the left-hand side of the `=` symbol determines whether it is parsed as item assignment or list assignment. See the section on [item and list assignment](/language/variables#Item_and_list_assignment) for a comparative discussion of the two assignment types.
  
  ## [infix `=>`](#Operators "go to top of document")[§](#infix_=> "direct link")
  
  ```raku
  sub infix:«=>»($key, Mu $value --> Pair:D)
  ```
  
  [`Pair`](/type/Pair) constructor.
  
  Constructs a [`Pair`](/type/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.
  
  ```raku
  my $p = a => 1;
  say $p.key;         # OUTPUT: «a␤»
  say $p.value;       # OUTPUT: «1␤»
  ```
  
  A [`Pair`](/type/Pair) within an argument list with an unquoted identifier on the left is interpreted as a named argument.
  
  See [the Terms language documentation](/language/terms#Pair) for more ways to create [`Pair`](/type/Pair) objects.
  
  # [Loose unary precedence](#Operators "go to top of document")[§](#Loose_unary_precedence "direct link")
  
  ## [prefix `not`](#Operators "go to top of document")[§](#prefix_not "direct link")
  
  ```raku
  multi prefix:<not>(Mu $x --> Bool:D)
  ```
  
  Evaluates its argument in Boolean context (and thus collapses [`Junction`](/type/Junction)s), and negates the result. Please note that `not` is easy to misuse. See [traps](/language/traps#Loose_Boolean_operators).
  
  ## [prefix `so`](#Operators "go to top of document")[§](#prefix_so "direct link")
  
  ```raku
  multi prefix:<so>(Mu $x --> Bool:D)
  ```
  
  Evaluates its argument in Boolean context (and thus collapses [`Junction`](/type/Junction)s), and returns the result.
  
  # [Comma operator precedence](#Operators "go to top of document")[§](#Comma_operator_precedence "direct link")
  
  ## [infix `,`](#Operators "go to top of document")[§](#infix_, "direct link")
  
  ```raku
  sub infix:<,>(*@a --> List:D) is assoc<list>
  ```
  
  Constructs a higher-order [`Cool`](/type/Cool) from its arguments.
  
  ```raku
  my @list = :god('Þor'), ['is',"mighty"];
  say @list;      # OUTPUT: «[god => Þor [is mighty]]␤»
  my %hash = :god('Þor'), :is("mighty");
  say %hash.raku; # OUTPUT: «{:god("Þor"), :is("mighty")}␤»
  my %a = :11a, :22b;
  say %(%a, :33x);  # OUTPUT: «{a => 11, b => 22, x => 33}␤»
  ```
  
  In the first case it returns a [`List`](/type/List), in the second case, since the arguments are [`Pair`](/type/Pair)s, it builds a [`Hash`](/type/Hash).
  
  It can also be used for constructing variables from other variables, collating elements of different types, in this case a [`Hash`](/type/Hash) and a [`Pair`](/type/Pair):
  
  ```raku
  my %features = %hash, :wields("hammer");
  say %features;  # OUTPUT: «{god => Þor, is => mighty, wields => hammer}␤»
  
  ```
  
  The comma is also used syntactically as the separator of arguments in calls.
  
  ## [infix `:`](#Operators "go to top of document")[§](#infix_: "direct link")
  
  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.
  
  ```raku
  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](#Operators "go to top of document")[§](#List_infix_precedence "direct link")
  
  ## [infix `Z`](#Operators "go to top of document")[§](#infix_Z "direct link")
  
  ```raku
  sub infix:<Z>(**@lists --> Seq:D) is assoc<list>
  ```
  
  The Zip operator interleaves the lists passed to `Z` like a zipper, taking index-corresponding elements from each operand. The returned [`Seq`](/type/Seq) contains nested lists, each with a value from every operand in the chain. If one of the operands runs out of elements prematurely, the zip operator will stop.
  
  ```raku
  say (1, 2 Z <a b c> Z <+ ->).raku;
  # OUTPUT: «((1, "a", "+"), (2, "b", "-")).Seq␤»
  for <a b c> Z <1 2 3 4> -> [$l, $r] {
      say "$l:$r"
  }
  # OUTPUT: «a:1␤b:2␤c:3␤»
  
  ```
  
  The `Z` operator also exists as a metaoperator, in which case the inner lists are replaced by the value from applying the operator to the list:
  
  ```raku
  say 100, 200 Z+ 42, 23;             # OUTPUT: «(142 223)␤»
  say 1..3 Z~ <a b c> Z~ 'x' xx 3;    # OUTPUT: «(1ax 2bx 3cx)␤»
  ```
  
  As any other infix operator, it can be used under its full name:
  
  ```raku
  say infix:<Z>(<a b>,<c d>);             # OUTPUT: «((a c) (b d))␤»
  
  ```
  
  If no argument is given, it will return an empty [`Seq`](/type/Seq)
  
  ```raku
  say infix:<Z>();                        # OUTPUT: «()␤»
  
  ```
  
  ## [infix `X`](#Operators "go to top of document")[§](#infix_X "direct link")
  
  ```raku
  multi infix:<X>(+lol, :&with! --> Seq:D)
  multi infix:<X>(+lol --> Seq:D)
  ```
  
  Creates a cross product from all the lists, ordered so that the rightmost elements vary most rapidly, and returns a [`Seq`](/type/Seq):
  
  ```raku
  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 metaoperator, in which case the inner lists are replaced by the value from applying the operator to the list:
  
  ```raku
  1..3 X~ <a b c> X~ 9
  # produces (1a9 1b9 1c9 2a9 2b9 2c9 3a9 3b9 3c9)
  ```
  
  ## [infix `...`](#Operators "go to top of document")[§](#infix_... "direct link")
  
  ```raku
  multi infix:<...>(**@) is assoc<list>
  multi infix:<...^>(**@) is assoc<list>
  multi infix:<^...>(**@) is assoc<list>
  multi infix:<^...^>(**@) is assoc<list>
  ```
  
  The sequence operator, which can be written either as `...` or as `…`, with variants `...^`, `^...`, `^...^`, `…^`, `^…` and `^…^`, will produce (possibly lazy) generic sequences on demand. Such sequences are of the [`Seq`](/type/Seq) type.
  
  The variants of the operator with an initial caret, `^...`, `^...^`, `^…` and `^…^`, produce sequences that do not contain the initial element.
  
  The variants of the operator with a final caret, `...^`, `^...^`, `…^` and `^…^`, produce sequences that do not contain the final element.
  
  Note: the variants `^...`, `^...^`, `^…` and `^…^` have been available in Rakudo compiler starting from 2020.05 release.
  
  The left-hand side of the operator specify the initial elements; it may include a generator after the first element or elements. The right-hand side will have an endpoint, which can be `Inf` or `*` for "infinite" lists (that is, *lazy* lists whose elements are only produced on demand), an expression which will end the sequence when `True`, or other elements such as [`Junction`](/type/Junction)s.
  
  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.
  
  An endpoint of `*` ([`Whatever`](/type/Whatever)), `Inf` or `∞` generates on demand an infinite sequence, with a default generator of `*.succ`
  
  ```raku
  say (1 ... *)[^5];  # OUTPUT: «(1 2 3 4 5)␤»
  ```
  
  Custom generators need to be the last element of the list before the '...' operator. This one takes two arguments, and generates the eight first Fibonacci numbers
  
  ```raku
  say (1, 1, -> $a, $b { $a + $b } ... *)[^8]; # OUTPUT: «(1 1 2 3 5 8 13 21)␤»
  # same but shorter
  say (1, 1, * + * ... *)[^8];                 # OUTPUT: «(1 1 2 3 5 8 13 21)␤»
  
  ```
  
  The generator can also take only one argument.
  
  ```raku
  say 5, { $_ * 2 } ... 40;                # OUTPUT: «5 10 20 40␤»
  ```
  
  Or it can use the [anonymous state variable `$`](/language/variables#index-entry-$_(variable)) to skip one position in the sequence when computing the next one:
  
  ```raku
  say (1, 1, 1, -> $a, $b, $ { $a + $b } … ∞)[3..10];
  # OUTPUT: «(2 2 3 4 5 7 9 12)␤»
  ```
  
  There must be at least as many initial elements as arguments to the generator.
  
  If the endpoint is not `*`, it's smartmatched against each generated element and the sequence is terminated when the smartmatch succeeded. The final element is excluded of the sequence if a sequence operator variant with a final caret is used, it is included otherwise.
  
  This allows you to write
  
  ```raku
  say 1, 1, * + * ...^ *>= 100;
  # OUTPUT: «(1 1 2 3 5 8 13 21 34 55 89)␤»
  ```
  
  to generate all Fibonacci numbers up to but excluding 100.
  
  The `...` operators consider the initial values as "generated elements" as well, so they are also checked against the endpoint:
  
  ```raku
  my $end = 4;
  say 1, 2, 4, 8, 16 ... $end;
  # OUTPUT: «(1 2 4)␤»
  ```
  
  If you do not provide a generator, the sequence operator tries to deduce the sequence. In most cases, this means using a default `*.`[succ](/routine/succ) or `*.`[pred](/routine/pred), depending on how the end points compare:
  
  ```raku
  say 1 ... 4;        # OUTPUT: «(1 2 3 4)␤»
  say 4 ... 1;        # OUTPUT: «(4 3 2 1)␤»
  say 1 ^... 4;       # OUTPUT: «(2 3 4)␤»
  say 1 ...^ 4;       # OUTPUT: «(1 2 3)␤»
  say 1 ^...^ 4;      # OUTPUT: «(2 3)␤»
  say 'a' ... 'e';    # OUTPUT: «(a b c d e)␤»
  say 'e' ... 'a';    # OUTPUT: «(e d c b a)␤»
  ```
  
  However, the sequence operator will deduce a different sequence in some special cases.
  
  If you provide more than one initial element and all initial elements are numeric, the sequence operator tries find an arithmetic or geometric sequence that fits the pattern in the initial elements:
  
  ```raku
  say 2, 4, 6 ... 12;     # OUTPUT: «(2 4 6 8 10 12)␤»
  say 1, 2, 4 ... 32;     # OUTPUT: «(1 2 4 8 16 32)␤»
  say 1, 2, 4 ^... 32;    # OUTPUT: «(2 4 8 16 32)␤»
  say 1, 2, 4 ^...^ 32;   # OUTPUT: «(2 4 8 16)␤»
  ```
  
  If you provide one [`Str`](/type/Str) initial element and a [`Str`](/type/Str) final element with the same number of characters, then the sequence operator will deduce a sequence of all strings where each letter is `le` the letter at the corresponding position in the final element:
  
  ```raku
  say 'aa' … 'cc';          # OUTPUT: «(aa ab ac ba bb bc ca cb cc)␤»
  # Which is the same as
  say 'a'..'c' X~ 'a'..'c'; # OUTPUT: «(aa ab ac ba bb bc ca cb cc)␤»
  ```
  
  # [List prefix precedence](#Operators "go to top of document")[§](#List_prefix_precedence "direct link")
  
  ## [infix `=` (list assignment)](#Operators "go to top of document")[§](#infix_=_(list_assignment) "direct link")
  
  The list assignment operator generally copies values from its right-hand side into the container on its left-hand side. Its exact semantics are left to the left-hand side container type. See [`Array`](/type/Array) and [`Hash`](/type/Hash) for common cases.
  
  The list assignment operator should be distinguished from the [item assignment operator](#infix_=_(item_assignment)), which uses the same operator symbol `=` but has a higher precedence. The context of the left-hand side of the `=` symbol determines whether it is parsed as item assignment or list assignment. See the section on [item and list assignment](/language/variables#Item_and_list_assignment) for a comparative discussion of the two assignment types.
  
  ## [infix `:=`](#Operators "go to top of document")[§](#infix_:= "direct link")
  
  Binding operator. Whereas `$x = $y` puts the value in `$y` into `$x`, `$x := $y` makes `$x` and `$y` the same thing.
  
  ```raku
  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](/language/containers#Binding) were different.
  
  ```raku
  my $a = 42;
  my $b := $a;
  $b++;
  say $a;
  ```
  
  This will output 43, since `$b` and `$a` both represented the same object.
  
  If type constrains on variables or containers are present a type check will be performed at runtime. On failure `X::TypeCheck::BindingType` will be thrown.
  
  Please note that `:=` is a compile time operator. As such it can not be referred to at runtime and thus can't be used as an argument to metaoperators.
  
  ## [infix `::=`](#Operators "go to top of document")[§](#infix_::= "direct link")
  
  Read-only binding operator, not yet implemented in Rakudo. See [`infix :=`](/routine/:=).
  
  ## [listop `...`](#Operators "go to top of document")[§](#listop_... "direct link")
  
  Called 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](/routine/fail), with the default message `Stub code executed`.
  
  This operator can be used for forward declarations of classes:
  
  ```raku
  class Foo {...}
  class Bar {
      has Foo $.foo;
  }
  class Foo {
      say "This is a Foo object";
  }
  
  ```
  
  or routines, such as this [`Sub`](/type/Sub):
  
  ```raku
  sub a() { ... }
  say a;           # OUTPUT: «42␤»
  sub a() { 42 }
  
  ```
  
  Please note that, in this case, it's not really necessary, and it will work the same without that forward declaration.
  
  ## [listop `!!!`](#Operators "go to top of document")[§](#listop_!!! "direct link")
  
  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](/routine/die), with the default message `Stub code executed`.
  
  ## [listop `???`](#Operators "go to top of document")[§](#listop_??? "direct link")
  
  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](/routine/warn), with the default message `Stub code executed`.
  
  ## [Reduction operators](#Operators "go to top of document")[§](#Reduction_operators "direct link")
  
  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.
  
  ```raku
  say [+] 1, 2, 3;      # 1 + 2 + 3 = 6
  my @a = (5, 6);
  say [*] @a;           # 5 * 6 = 30
  ```
  
  Reduction operators have the same associativity as the operators they are based on.
  
  ```raku
  say [-] 4, 3, 2;      # 4-3-2 = (4-3)-2 = -1
  say [**] 4, 3, 2;     # 4**3**2 = 4**(3**2) = 262144
  ```
  
  Applying [+] to a single element will return that element
  
  ```raku
  say [+] 42;           # OUTPUT: «42␤»
  
  ```
  
  # [Loose AND precedence](#Operators "go to top of document")[§](#Loose_AND_precedence "direct link")
  
  ## [`and`](#Operators "go to top of document")[§](#infix_and "direct link")
  
  Same as [infix &&](#infix_%26%26), except with looser precedence.
  
  Short-circuits so that it returns the first operand that evaluates to `False`, otherwise returns the last operand. Note that `and` is easy to misuse, see [traps](/language/traps#Loose_Boolean_operators).
  
  ## [`andthen`](#Operators "go to top of document")[§](#infix_andthen "direct link")
  
  The `andthen` operator returns [`Empty`](/type/Slip#constant_Empty) upon encountering the first [undefined](/routine/defined) argument, otherwise the last argument. Last argument is returned as-is, without being checked for definedness at all. 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`](/type/Callable), whose [count](/routine/count) must be `0` or `1`.
  
  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 (tip: [`Failure`](/type/Failure)s are never defined, so you can handle them with this operator).
  
  ```raku
  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 a defined value. The aliasing behavior lets us pipe the values across the operator.
  
  The `andthen` operator is a close relative of the [`with` statement modifier](/language/control#with_orwith_without), and some compilers compile `with` to `andthen`, meaning these two lines have equivalent behavior:
  
  ```raku
  .say with 42;
  42 andthen .say;
  ```
  
  ## [`notandthen`](#Operators "go to top of document")[§](#infix_notandthen "direct link")
  
  The `notandthen` operator returns [`Empty`](/type/Slip#constant_Empty) upon encountering the first [defined](/routine/defined) argument, otherwise the last argument. Last argument is returned as-is, without being checked for definedness at all. 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`](/type/Callable), whose [count](/routine/count) must be `0` or `1`.
  
  At first glance, [notandthen](/routine/notandthen) might appear to be the same thing as the [orelse](/routine/orelse) operator. The difference is subtle: [notandthen](/routine/notandthen) returns [`Empty`](/type/Slip#constant_Empty) when it encounters a [defined](/routine/defined) item (that isn't the last item), whereas [orelse](/routine/orelse) returns that item. In other words, [notandthen](/routine/notandthen) is a means to act when items aren't defined, whereas [orelse](/routine/orelse) is a means to obtain the first defined item:
  
  ```raku
  sub all-sensors-down     { [notandthen] |@_, True             }
  sub first-working-sensor { [orelse]     |@_, 'default sensor' }
  
  all-sensors-down Nil, Nil, Nil
    and say 'OMG! All sensors are down!'; # OUTPUT:«OMG! All sensors are down!␤»
  say first-working-sensor Nil, Nil, Nil; # OUTPUT:«default sensor␤»
  
  all-sensors-down Nil, 42, Nil
    and say 'OMG! All sensors are down!'; # No output
  say first-working-sensor Nil, 42, Nil;  # OUTPUT:«42␤»
  
  ```
  
  The `notandthen` operator is a close relative of the [`without` statement modifier](/language/control#with_orwith_without), and some compilers compile `without` to `notandthen`, meaning these two lines have equivalent behavior:
  
  ```raku
  sub good-things { fail }
  
  'boo'.say without good-things;
  good-things() notandthen 'boo'.say;
  
  ```
  
  # [Loose OR precedence](#Operators "go to top of document")[§](#Loose_OR_precedence "direct link")
  
  ## [infix `or`](#Operators "go to top of document")[§](#infix_or "direct link")
  
  Same as [infix `||`](/routine/||), 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](/language/traps#Loose_Boolean_operators).
  
  ## [infix `orelse`](#Operators "go to top of document")[§](#infix_orelse "direct link")
  
  The `orelse` operator is similar to `infix //`, except with looser precedence and `$_` aliasing.
  
  Returns the first defined argument, or else the last argument. Last argument is returned as-is, without being checked for definedness at all. Short-circuits. The result of the left side is bound to `$_` for the right side, or passed as an argument if the right side is a [`Callable`](/type/Callable), whose [count](/routine/count) must be `0` or `1`.
  
  This operator is useful for handling [`Failure`](/type/Failure)s returned by routines since the expected value is usually [defined](/routine/defined) and [`Failure`](/type/Failure) never is:
  
  ```raku
  sub meows { ++$ < 4 ?? fail 'out of meows!' !! '🐱' }
  
  sub meows-processor1 { meows() orelse .return } # return handled Failure
  sub meows-processor2 { meows() orelse fail $_ } # return re-armed Failure
  sub meows-processor3 {
      # Use non-Failure output, or else print a message that stuff's wrong
      meows() andthen .say orelse ‘something's wrong’.say;
  }
  
  say "{.^name}, {.handled}"  # OUTPUT: «Failure, True␤»
      given meows-processor1;
  say "{.^name}, {.handled}"  # OUTPUT: «Failure, False␤»
      given meows-processor2;
  meows-processor3;           # OUTPUT: «something's wrong␤»
  meows-processor3;           # OUTPUT: «🐱␤»
  ```
  
  ## [infix `xor`](#Operators "go to top of document")[§](#infix_xor "direct link")
  
  Same as [infix `^^`](/routine/$CIRCUMFLEX_ACCENT$CIRCUMFLEX_ACCENT), except with looser precedence.
  
  Returns the operand that evaluates to `True` in Boolean context, if and only if the other operand evaluates to `False` in Boolean context. If both operands evaluate to `False`, returns the last argument. If both operands evaluate to `True`, returns [`Nil`](/type/Nil).
  
  When chaining, returns the operand that evaluates to `True`, if and only if there is one such operand. If more than one operand is true, it short-circuits after evaluating the second and returns [`Nil`](/type/Nil). If all operands are false, returns the last one.
  
  # [Sequencer precedence](#Operators "go to top of document")[§](#Sequencer_precedence "direct link")
  
  ## [infix `==>`](#Operators "go to top of document")[§](#infix_==> "direct link")
  
  This feed operator takes the result from the left and passes it to the next (right) routine as the last parameter.
  
  ```raku
  my @array = (1, 2, 3, 4, 5);
  @array ==> sum() ==> say();   # OUTPUT: «15␤»
  ```
  
  This simple example, above, is the equivalent of writing:
  
  ```raku
  my @array = (1, 2, 3, 4, 5);
  say(sum(@array));             # OUTPUT: «15␤»
  ```
  
  Or if using methods:
  
  ```raku
  my @array = (1, 2, 3, 4, 5);
  @array.sum.say;               # OUTPUT: «15␤»
  ```
  
  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).
  
  This "traditional" structure, read bottom-to-top, with the last two lines creating the data structure that is going to be processed
  
  ```raku
  my @fractions = <TWO THREE FOUR FIVE SEVEN> »~» " " X~ <FIFTHS SIXTHS EIGHTHS>;
  my @result = map { .uniparse },                    # (3) Converts to unicode
      grep { .uniparse },                            # (2) Checks if it parses
      map( {"VULGAR FRACTION " ~ $^þ }, @fractions); # (1) Adds string to input
  
  # @result is [⅖ ⅗ ⅜ ⅘ ⅚ ⅝ ⅞]
  ```
  
  Now we use the feed operator (left-to-right) with parentheses, read top-to-bottom
  
  ```raku
  my @result = (
      <TWO THREE FOUR FIVE SEVEN> »~» " " X~ <FIFTHS SIXTHS EIGHTHS> # (1) Input
      ==> map( {"VULGAR FRACTION " ~ $^þ } )                         # (2) Converts to Unicode name
      ==> grep({ .uniparse })                                        # (3) Filters only real names
      ==> map( { .uniparse} );                                       # (4) Converts to unicode
  );
  ```
  
  For illustration, method chaining equivalent, read top-to-bottom, using the same sequence as above
  
  ```raku
  my @result = ( <TWO THREE FOUR FIVE SEVEN> »~» " " X~ <FIFTHS SIXTHS EIGHTHS>)
      .map( {"VULGAR FRACTION " ~ $^þ } )
      .grep({ .uniparse })
      .map({ .uniparse });
  ```
  
  Although in this particular case the result is the same, the feed operator `==>` more clearly shows intent with arrow pointing in the direction of the data flow. To assign without the need of parentheses use another feed operator
  
  ```raku
  <people of earth>
      ==> map({ .tc })
      ==> grep /<[PE]>/
      ==> sort()
      ==> my @result;
  ```
  
  It can be useful to capture a partial result, however, unlike the leftward feed operator, it does require parentheses or a semicolon
  
  ```raku
  <people of earth>
      ==> map({ .tc })
      ==> my @caps; @caps   # also could wrap in parentheses: (my @caps)
      ==> grep /<[PE]>/
      ==> sort()
      ==> my @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 `<==`](#Operators "go to top of document")[§](#infix_<== "direct link")
  
  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.
  
  ```raku
  # 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)