txt: ## operators.md
  ## Chunk 4 of 6
   infix:<ne>(Mu,    Mu)
  multi infix:<ne>(Str:D, Str:D)
  ```
  
  String inequality operator.
  
  Coerces both arguments to [`Str`](/type/Str) (if necessary); returns `False` if both are equal.
  
  Mnemonic: *not equal*
  
  ## [infix `gt`](#Operators "go to top of document")[§](#infix_gt "direct link")
  
  ```raku
  multi infix:<gt>(Mu,    Mu)
  multi infix:<gt>(Str:D, Str:D)
  ```
  
  String greater than operator.
  
  Coerces both arguments to [`Str`](/type/Str) (if necessary); returns `True` if the first is larger than the second, as determined by lexicographic comparison.
  
  Mnemonic: *greater than*
  
  ## [infix `ge`](#Operators "go to top of document")[§](#infix_ge "direct link")
  
  ```raku
  multi infix:<ge>(Mu,    Mu)
  multi infix:<ge>(Str:D, Str:D)
  ```
  
  String greater than or equal to operator.
  
  Coerces both arguments to [`Str`](/type/Str) (if necessary); returns `True` if the first is equal to or larger than the second, as determined by lexicographic comparison.
  
  Mnemonic: *greater or equal*
  
  ## [infix `lt`](#Operators "go to top of document")[§](#infix_lt "direct link")
  
  ```raku
  multi infix:<lt>(Mu,    Mu)
  multi infix:<lt>(Str:D, Str:D)
  ```
  
  String less than operator.
  
  Coerces both arguments to [`Str`](/type/Str) (if necessary); returns `True` if the first is smaller than the second, as determined by lexicographic comparison.
  
  Mnemonic: *less than*
  
  ## [infix `le`](#Operators "go to top of document")[§](#infix_le "direct link")
  
  ```raku
  multi infix:<le>(Mu,    Mu)
  multi infix:<le>(Str:D, Str:D)
  ```
  
  String less than or equal to operator.
  
  Coerces both arguments to [`Str`](/type/Str) (if necessary); returns `True` if the first is equal to or smaller than the second, as determined by lexicographic comparison.
  
  Mnemonic: *less or equal*
  
  ## [infix `before`](#Operators "go to top of document")[§](#infix_before "direct link")
  
  ```raku
  multi infix:<before>(Any,       Any)
  multi infix:<before>(Real:D,    Real:D)
  multi infix:<before>(Str:D,     Str:D)
  multi infix:<before>(Version:D, Version:D)
  ```
  
  Generic ordering, uses the same semantics as [cmp](/routine/cmp). Returns `True` if the first argument is smaller than the second.
  
  ## [infix `after`](#Operators "go to top of document")[§](#infix_after "direct link")
  
  ```raku
  multi infix:<after>(Any,       Any)
  multi infix:<after>(Real:D,    Real:D)
  multi infix:<after>(Str:D,     Str:D)
  multi infix:<after>(Version:D, Version:D)
  ```
  
  Generic ordering, uses the same semantics as [cmp](/routine/cmp). Returns `True` if the first argument is larger than the second.
  
  ## [infix `eqv`](#Operators "go to top of document")[§](#infix_eqv "direct link")
  
  ```raku
  sub infix:<eqv>(Any, Any)
  ```
  
  This could be called an equivalence operator, and it will return `True` if the two arguments are structurally the same, i.e. from the same type and (recursively) contain equivalent values.
  
  ```raku
  say [1, 2, 3] eqv [1, 2, 3];    # OUTPUT: «True␤»
  say Any eqv Any;                # OUTPUT: «True␤»
  say 1 eqv 2;                    # OUTPUT: «False␤»
  say 1 eqv 1.0;                  # OUTPUT: «False␤»
  ```
  
  Lazy [`Iterable`](/type/Iterable)s cannot be compared, as they're assumed to be infinite. However, the operator will do its best and return `False` if the two lazy [`Iterable`](/type/Iterable)s are of different types or if only one [`Iterable`](/type/Iterable) is lazy.
  
  ```raku
  say (1…∞) eqv (1…∞).List; # Both lazy, but different types;   OUTPUT: «False␤»
  say (1…∞) eqv (1…3);      # Same types, but only one is lazy; OUTPUT: «False␤»
  (try say (1…∞) eqv (1…∞)) # Both lazy and of the same type. Cannot compare; throws.
      orelse say $!.^name;  # OUTPUT: «X::Cannot::Lazy␤»
  ```
  
  In some cases, it will be able to compare lazy operands, as long as they can be iterated
  
  ```raku
  my $a = lazy ^2;
  my $b = $a;
  $a.cache;
  say $a eqv $b; # OUTPUT: «True␤»
  
  ```
  
  When cached, the two lazy [`Seq`](/type/Seq)s can be iterated over, and thus compared.
  
  The default `eqv` operator even works with arbitrary objects. E.g., `eqv` will consider two instances of the same object as being structurally equivalent:
  
  ```raku
  my class A {
      has $.a;
  }
  say A.new(a => 5) eqv A.new(a => 5);  # OUTPUT: «True␤»
  ```
  
  Although the above example works as intended, the `eqv` code might 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:
  
  ```raku
  my class A {
      has $.a;
  }
  multi infix:<eqv>(A $l, A $r) { $l.a eqv $r.a }
  say A.new(a => 5) eqv A.new(a => 5);            # OUTPUT: «True␤»
  ```
  
  Note that `eqv` does not work recursively on every kind of container type, e.g. [`Set`](/type/Set):
  
  ```raku
  my class A {
      has $.a;
  }
  say Set(A.new(a => 5)) eqv Set(A.new(a => 5));  # OUTPUT: «False␤»
  ```
  
  Even though the contents of the two sets are `eqv`, the sets are not. The reason is that `eqv` delegates the equality check to the [`Set`](/type/Set) object which relies on element-wise `===` comparison. Turning the class `A` into a value type ([`ValueObjAt`](/type/ValueObjAt)) by giving it a `WHICH` method produces the expected behavior:
  
  ```raku
  my class A {
      has $.a;
      method WHICH {
          ValueObjAt.new: "A|$!a.WHICH()"
      }
  }
  say Set(A.new(a => 5)) eqv Set(A.new(a => 5));  # OUTPUT: «True␤»
  ```
  
  You can call a single-argument version of the operator by using its full name; it will always return true.
  
  ```raku
  say infix:<eqv>(33);    # OUTPUT: «True␤»
  say infix:<eqv>(False); # OUTPUT: «True␤»
  
  ```
  
  ## [infix `===`](#Operators "go to top of document")[§](#infix_=== "direct link")
  
  ```raku
  sub infix:<===>(Any, Any)
  ```
  
  The ASCII equivalent of [`⩶`](#infix_⩶), the value identity operator.
  
  Before Rakudo version 2021.07, the ASCII variant was the *only* variant.
  
  ## [infix `⩶`](#Operators "go to top of document")[§](#infix_⩶ "direct link")
  
  ```raku
  sub infix:<⩶>(Any, Any)
  ```
  
  ⩶ Value identity operator. Returns `True` if both arguments are the same object, disregarding any containerization.
  
  ```raku
  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`:
  
  ```raku
  say 'a' ⩶ 'a';            # OUTPUT: «True␤»
  say 'a' ⩶ 'b';            # OUTPUT: «False␤»
  
  my $b = 'a';
  say $b ⩶ 'a';             # OUTPUT: «True␤»
  
  # different types
  say 1 ⩶ 1.0;              # OUTPUT: «False␤»
  ```
  
  `⩶` uses the [WHICH](/routine/WHICH) method to obtain the object identity.
  
  If you want to create a class that should act as a value type, then that class must create an instance method `WHICH`, that should return a [`ValueObjAt`](/type/ValueObjAt) object that won't change for the lifetime of the object.
  
  The ASCII equivalent of this operator is [`===`](#infix_===).
  
  ## [infix `=:=`](#Operators "go to top of document")[§](#infix_=:= "direct link")
  
  ```raku
  multi infix:<=:=>(Mu \a, Mu \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.
  
  ```raku
  my ($a, $b) = (1, 3);
  say $a =:= $b;      # OUTPUT: «False␤»
  $b = 2;
  say $a;             # OUTPUT: «1␤»
  $b := $a;
  say $a =:= $b;      # OUTPUT: «True␤»
  $a = 5;
  say $b;             # OUTPUT: «5␤»
  ```
  
  The single argument version, called as a routine, will always return True:
  
  ```raku
  say infix:<=:=>(42);    # OUTPUT: «True␤»
  say infix:<=:=>(False); # OUTPUT: «True␤»
  
  ```
  
  ## [infix `~~`](#Operators "go to top of document")[§](#infix_~~ "direct link")
  
  The smartmatch 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 a partial list of some of the built-in smartmatching functionality. For full details, see [ACCEPTS](/routine/ACCEPTS) documentation for the type on the right-hand side of the operator.
  
  | 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 `=~=`](#Operators "go to top of document")[§](#infix_=~= "direct link")
  
  The ASCII equivalent of [`≅`](#infix_≅), the approximately-equal operator.
  
  ## [infix `≅`](#Operators "go to top of document")[§](#infix_≅ "direct link")
  
  ```raku
  multi infix:<≅>(Any, Any)
  multi infix:<≅>(Int:D, Int:D)
  multi infix:<≅>(Num:D, Num:D)
  multi infix:<≅>(Rational:D, Rational:D)
  multi infix:<≅>(Real:D, Real:D)
  multi infix:<≅>(Complex:D, Complex:D)
  multi infix:<≅>(Numeric:D, Numeric:D)
  ```
  
  The approximately-equal operator `≅` calculates the [relative percentage difference](https://en.wikipedia.org/wiki/Relative_change) 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`.
  
  The ASCII equivalent of this operator is [`=~=`](#infix_=~=).
  
  Note that this operator is not arithmetically symmetrical (doesn't do ± Δ):
  
  ```raku
  my $x = 1;
  say ($x + $*TOLERANCE) ≅ $x;   # OUTPUT: «False␤»
  say ($x - $*TOLERANCE) ≅ $x;   # OUTPUT: «True␤»
  ```
  
  You can change `$*TOLERANCE` lexically:
  
  ```raku
  {
      my $*TOLERANCE = .1;
      say 11 ≅ 10;        # OUTPUT: «True␤»
  }
  ```
  
  Note that setting `$*TOLERANCE = 0` will cause all comparisons to fail.
  
  ```raku
  {
      my $*TOLERANCE = 0;
      say 1 ≅ 1;        # OUTPUT: «False␤»
  }
  ```
  
  ## [infix (elem), infix ∈](#Operators "go to top of document")[§](#infix_(elem),_infix_∈ "direct link")
  
  ```raku
  multi infix:<(elem)>($a,$b --> Bool:D)
  ```
  
  Membership operator.
  
  Returns `True` if `$a` is an **element** of `$b`.
  
  ```raku
  say 2 (elem) (1, 2, 3); # OUTPUT: «True␤»
  say 4 ∈ (1, 2, 3);      # OUTPUT: «False␤»
  
  ```
  
  Since release 2020.05, ∊ is an alias for this operator.
  
  ## [infix `∉`](#Operators "go to top of document")[§](#infix_∉ "direct link")
  
  ```raku
  multi infix:<∉>($a,$b --> Bool:D)
  ```
  
  Non-membership operator.
  
  Returns `True` if `$a` is **not** an **element** of `$b`. Equivalent to `!(elem)`.
  
  ```raku
  say 4 ∉ (1, 2, 3);       # OUTPUT: «True␤»
  say 2 !(elem) (1, 2, 3); # OUTPUT: «False␤»
  
  ```
  
  ## [infix `(==)`, infix `≡`](#Operators "go to top of document")[§](#infix_(==),_infix_≡ "direct link")
  
  ```raku
  multi infix:<(==)>($a,$b --> Bool:D)
  ```
  
  Set equality operator.
  
  Returns `True` if `$a` and `$b` are **identical**.
  
  ```raku
  say (1, 2, 3) (==) (1, 3, 2); # OUTPUT: «True␤»
  say (1, 2, 3) ≡ (1, 2, 4); # OUTPUT: «False␤»
  
  ```
  
  ## [infix `≢`](#Operators "go to top of document")[§](#infix_≢ "direct link")
  
  ```raku
  multi infix:<≢>($a,$b --> Bool:D)
  ```
  
  Set inequality operator.
  
  Returns `True` if `$a` and `$b` are **not identical**. Equivalent to `!(==)`.
  
  ```raku
  say (1, 2, 3) ≢ (1, 2, 4); # OUTPUT: «True␤»
  say (1, 2, 3) ≢ (1, 3, 2); # OUTPUT: «False␤»
  
  ```
  
  ## [infix (cont), infix ∋](#Operators "go to top of document")[§](#infix_(cont),_infix_∋ "direct link")
  
  ```raku
  multi infix:<(cont)>($a,$b --> Bool:D)
  ```
  
  Membership operator.
  
  Returns `True` if `$a` **contains** `$b` as an element.
  
  ```raku
  say (1,2,3) (cont) 2; # OUTPUT: «True␤»
  say (1, 2, 3) ∋ 4;    # OUTPUT: «False␤»
  
  ```
  
  Since release 2020.05, ∍ is an alias for this operator.
  
  ## [infix `∌`](#Operators "go to top of document")[§](#infix_∌ "direct link")
  
  ```raku
  multi infix:<∌>($a,$b --> Bool:D)
  ```
  
  Non-membership operator.
  
  Returns `True` if `$a` does **not** **contain** `$b`. Equivalent to `!(cont)`.
  
  ```raku
  say (1,2,3) ∌ 4;       # OUTPUT: «True␤»
  say (1,2,3) !(cont) 2; # OUTPUT: «False␤»
  
  ```
  
  ## [infix `(<)`, infix `⊂`](#Operators "go to top of document")[§](#infix_(<),_infix_⊂ "direct link")
  
  ```raku
  multi infix:«(<)»($a,$b --> Bool:D)
  ```
  
  Subset of operator.
  
  Returns `True` if `$a` is a **strict subset** of `$b`, i.e., that all the elements of `$a` are elements of `$b` but `$a` is a smaller set than `$b`.
  
  ```raku
  say (1,2,3) (<) (2,3,1); # OUTPUT: «False␤»
  say (2,3) (<) (2,3,1);   # OUTPUT: «True␤»
  say 4 ⊂ (1,2,3);         # OUTPUT: «False␤»
  
  ```
  
  ## [infix `⊄`](#Operators "go to top of document")[§](#infix_⊄ "direct link")
  
  ```raku
  multi infix:<⊄>($a,$b --> Bool:D)
  ```
  
  Not a subset of operator.
  
  Returns `True` if `$a` is **not** a `strict subset` of `$b`. Equivalent to `!(<)`.
  
  ```raku
  say (1,2,3) ⊄ (2,3,1); # OUTPUT: «True␤»
  say (2,3) ⊄ (2,3,1);   # OUTPUT: «False␤»
  say 4 !(<) (1,2,3);    # OUTPUT: «True␤»
  
  ```
  
  ## [infix `(<=)`, infix `⊆`](#Operators "go to top of document")[§](#infix_(<=),_infix_⊆ "direct link")
  
  ```raku
  multi infix:«(<=)»($a,$b --> Bool:D)
  ```
  
  Subset of or equal to operator.
  
  Returns `True` if `$a` is a **subset** of `$b`, i.e., that all the elements of `$a` are elements of `$b` but `$a` is a smaller or equal sized set than `$b`.
  
  ```raku
  say (1,2,3) (<=) (2,3,1); # OUTPUT: «True␤»
  say (2,3) (<=) (2,3,1);   # OUTPUT: «True␤»
  say 4 ⊆ (1,2,3);          # OUTPUT: «False␤»
  
  ```
  
  ## [infix `⊈`](#Operators "go to top of document")[§](#infix_⊈ "direct link")
  
  ```raku
  multi infix:<⊈>($a,$b --> Bool:D)
  ```
  
  Not a subset of nor equal to operator.
  
  Returns `True` if `$a` is **not** a `subset` of `$b`. Equivalent to `!(<=)`.
  
  ```raku
  say (1,2,3) ⊈ (2,3,1); # OUTPUT: «False␤»
  say (2,3) ⊈ (2,3,1);   # OUTPUT: «False␤»
  say 4 !(<=) (1,2,3);   # OUTPUT: «True␤»
  
  ```
  
  ## [infix `(>)`, infix `⊃`](#Operators "go to top of document")[§](#infix_(>),_infix_⊃ "direct link")
  
  ```raku
  multi infix:«(>)»($a,$b --> Bool:D)
  ```
  
  Superset of operator.
  
  Returns `True` if `$a` is a **strict superset** of `$b`, i.e., that all the elements of `$b` are elements of `$a` but `$a` is a larger set than `$b`.
  
  ```raku
  say (1,2,3) (>) (2,3,1); # OUTPUT: «False␤»
  say (1,2,3) (>) (2,3);   # OUTPUT: «True␤»
  say 4 ⊃ (1,2,3);         # OUTPUT: «False␤»
  
  ```
  
  ## [infix `⊅`](#Operators "go to top of document")[§](#infix_⊅ "direct link")
  
  ```raku
  multi infix:<⊅>($a,$b --> Bool:D)
  ```
  
  Not a superset of operator.
  
  Returns `True` if `$a` is **not** a `strict superset` of `$b`. Equivalent to `!(>)`.
  
  ```raku
  say (1,2,3) ⊅ (2,3,1); # OUTPUT: «True␤»
  say (1,2,3) ⊅ (2,3);   # OUTPUT: «False␤»
  say 4 !(>) (1,2,3);    # OUTPUT: «True␤»
  
  ```
  
  ## [infix `(>=)`, infix `⊇`](#Operators "go to top of document")[§](#infix_(>=),_infix_⊇ "direct link")
  
  ```raku
  multi infix:«(>=)»($a,$b --> Bool:D)
  ```
  
  Superset of or equal to operator.
  
  Returns `True` if `$a` is a **superset** of `$b`, i.e., that all the elements of `$b` are elements of `$a` but `$a` is a larger or equal sized set than `$b`.
  
  ```raku
  say (1,2,3) (>=) (2,3,1); # OUTPUT: «True␤»
  say (1,2,3) (>=) (2,3);   # OUTPUT: «True␤»
  say 4 ⊇ (1,2,3);          # OUTPUT: «False␤»
  
  ```
  
  ## [infix `⊉`](#Operators "go to top of document")[§](#infix_⊉ "direct link")
  
  ```raku
  multi infix:<⊉>($a,$b --> Bool:D)
  ```
  
  Not a superset of nor equal to operator.
  
  Returns `True` if `$a` is **not** a `superset` of `$b`. Equivalent to `!(>=)`.
  
  ```raku
  say (1,2,3) ⊉ (2,3,1); # OUTPUT: «False␤»
  say (1,2,3) ⊉ (2,3);   # OUTPUT: «False␤»
  say 4 !(>=) (1,2,3);   # OUTPUT: «True␤»
  
  ```
  
  ## [infix `≼`, infix `≽`](#Operators "go to top of document")[§](#infix_≼,_infix_≽ "direct link")
  
  Deprecated. These were removed in v6.d, please use ⊆ and ⊇ operators instead.
  
  # [Tight AND precedence](#Operators "go to top of document")[§](#Tight_AND_precedence "direct link")
  
  ## [infix `&&`](#Operators "go to top of document")[§](#infix_&& "direct link")
  
  Returns the first argument that evaluates to `False` in Boolean context, otherwise returns 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 are never evaluated.
  
  ```raku
  sub a { 1 }
  sub b { 0 }
  sub c { die "never called" };
  say a() && b() && c();      # OUTPUT: «0␤»
  ```
  
  # [Tight OR precedence](#Operators "go to top of document")[§](#Tight_OR_precedence "direct link")
  
  ## [infix `||`](#Operators "go to top of document")[§](#infix_|| "direct link")
  
  Returns the first argument that evaluates to `True` in Boolean context, otherwise returns the last argument.
  
  Note that this short-circuits; i.e., if one of the arguments evaluates to a true value, the remaining arguments are not evaluated.
  
  ```raku
  sub a { 0 }
  sub b { 1 }
  sub c { die "never called" };
  say a() || b() || c();      # OUTPUT: «1␤»
  ```
  
  ## [infix `^^`](#Operators "go to top of document")[§](#infix_^^ "direct link")
  
  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`](/type/Nil) 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.
  
  ```raku
  say 0 ^^ 42;                             # OUTPUT: «42␤»
  say '' ^^ 0;                             # OUTPUT: «0␤»
  say 0 ^^ 42 ^^ 1 ^^ die "never called";  # OUTPUT: «Nil␤»
  ```
  
  Note that the semantics of this operator may not be what you assume: infix `^^` flips to the 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 `//`](#Operators "go to top of document")[§](#infix_// "direct link")
  
  The defined-or operator or infix // returns the first defined operand, or else the last operand. Short-circuits.
  
  ```raku
  say Any // 0 // 42;         # OUTPUT: «0␤»
  ```
  
  ## [infix `min`](#Operators "go to top of document")[§](#infix_min "direct link")
  
  Returns the smallest of the arguments, as determined by [cmp](/routine/cmp) semantics.
  
  ```raku
  my $foo = 42;
  $foo min= 0   # read as: $foo decreases to 0
  ```
  
  **Note:** Before 2022.06, in the cases of ties [`&min`](/type/Any#routine_min) would return the first argument with that value, whereas `&[min]` would return its RHS. After 2022.06, `&[min]` returns its LHS in the case of ties, and now both return the same value as dictated by their List associativity.
  
  ```raku
  say min 0, False; # OUTPUT: «0␤»
  say 0 min False;  # OUTPUT: «0␤»
  say min False, 0; # OUTPUT: «False␤»
  say False min 0;  # OUTPUT: «False␤»
  ```
  
  ## [infix `max`](#Operators "go to top of document")[§](#infix_max "direct link")
  
  Returns the largest of the arguments, as determined by [cmp](/routine/cmp) semantics.
  
  ```raku
  my $foo = -42;
  $foo max= 0   # read as: $foo increases to 0
  ```
  
  **Note:** Before 2022.06, in the cases of ties [`&max`](/type/Any#routine_max) would return the first argument with that value, whereas `&[max]` would return its RHS. After 2022.06, `&[max]` returns its LHS in the case of ties, and now both return the same value as dictated by their List associativity.
  
  ```raku
  say max 0, False; # OUTPUT: «0␤»
  say 0 max False;  # OUTPUT: «0␤»
  say max False, 0; # OUTPUT: «False␤»
  say False max 0;  # OUTPUT: «False␤»
  ```
  
  ## [infix `minmax`](#Operators "go to top of document")[§](#infix_minmax "direct link")
  
  Returns the [`Range`](/type/Range) starting from the lowest to the highest of the values, as determined by the [cmp](/routine/cmp) semantics. For instance:
  
  ```raku
  # numeric comparison
  10 minmax 3;     # 3..10
  
  # string comparison
  '10' minmax '3'; # "10".."3"
  'z' minmax 'k';  # "k".."z"
  
  ```
  
  If the lowest and highest values coincide, the operator returns a [`Range`](/type/Range) made by the same value:
  
  ```raku
  1 minmax 1;  # 1..1
  
  ```
  
  When applied to [`List`](/type/List)s, the operator evaluates the lowest and highest values among all available values:
  
  ```raku
  (10,20,30) minmax (0,11,22,33);       # 0..33
  ('a','b','z') minmax ('c','d','w');   # "a".."z"
  
  ```
  
  Similarly, when applied to [`Hash`](/type/Hash)es, it performs a [cmp](/routine/cmp) way comparison:
  
  ```raku
  my %winner = points => 30, misses => 10;
  my %loser = points => 20, misses => 10;
  %winner cmp %loser;      # More
  %winner minmax %loser;
  # ${:misses(10), :points(20)}..${:misses(10), :points(30)}
  
  ```
  
  # [Conditional operator precedence](#Operators "go to top of document")[§](#Conditional_operator_precedence "direct link")
  
  ## [infix `?? !!`](#Operators "go to top of document")[§](#infix_??_!! "direct link")
  
  Also called *ternary* or *conditional* operator, `$condition ?? $true !! $false` evaluates `$condition` and returns the expression right behind ??, in this case `$true` if it is `True`, otherwise evaluates and returns the expression behind !!, `$false` in this case.
  
  ## [infix `ff`](#Operators "go to top of document")[§](#infix_ff "direct link")
  
  ```raku
  sub infix:<ff>(Mu $a, Mu $b)
  ```
  
  Also called the *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:
  
  ```raku
  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:
  
  ```raku
  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 such.
  
  ```raku
  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](/routine/fff).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  ## [infix `^ff`](#Operators "go to top of document")[§](#infix_^ff "direct link")
  
  ```raku
  sub infix:<^ff>(Mu $a, Mu $b)
  ```
  
  Works like [ff](/routine/ff), except it does not return `True` for items matching the start condition (including items also matching the stop condition).
  
  A comparison:
  
  ```raku
  my @list = <X A B C Y>;
  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`](/routine/$CIRCUMFLEX_ACCENTfff).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  ## [infix `ff^`](#Operators "go to top of document")[§](#infix_ff^ "direct link")
  
  ```raku
  sub infix:<ff^>(Mu $a, Mu $b)
  ```
  
  Works like [ff](/routine/ff), except it does not return `True` for items matching the stop condition (including items that first matched the start condition).
  
  ```raku
  my @list = <X A B C Y>;
  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^](/routine/fff$CIRCUMFLEX_ACCENT).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  ## [infix `^ff^`](#Operators "go to top of document")[§](#infix_^ff^ "direct link")
  
  ```raku
  sub infix:<^ff^>(Mu $a, Mu $b)
  ```
  
  Works like [ff](/routine/ff), except it does not return `True` for items matching either the stop or start condition (or both).
  
  ```raku
  my @list = <X A B C Y>;
  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^`](/routine/$CIRCUMFLEX_ACCENTfff$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)
  ```
  
  Performs a sed-like flipflop operation, wherein it returns `False` until the left argument smartmatches against `$_`, then returns `True` until the right argument smartmatches against `$_`.
  
  Works similarly to [ff](/routine/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.
  
  ```raku
  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](/routine/ff).
  
  This operator cannot be overloaded, as it's handled specially by the compiler.
  
  ## [infix `^fff`](#Operators