Red::Operators

multi sub prefix:<–>

multi sub prefix:<-->(
    Red::Column $a
) returns Mu

–X

multi sub prefix:<++>

multi sub prefix:<++>(
    Red::Column $a
) returns Mu

++X

multi sub postfix:<–>

multi sub postfix:<-->(
    Red::Column $a
) returns Mu

X–

multi sub postfix:<++>

multi sub postfix:<++>(
    Red::AST $a
) returns Mu

X++

multi sub prefix:<->

multi sub prefix:<->(
    Red::AST $a
) returns Mu

-X

multi sub prefix:<+>

multi sub prefix:<+>(
    Red::AST $a
) returns Mu

+X

multi sub infix:<+>

multi sub infix:<+>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X + Y

multi sub infix:<+>

multi sub infix:<+>(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X + Y # Where Y is castable to Numeric

multi sub infix:<+>

multi sub infix:<+>(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X + Y # Where X is castable to Numeric

multi sub infix:<->

multi sub infix:<->(
    Red::AST $a,
    Red::AST $b
) returns Mu

X - Y

multi sub infix:<->

multi sub infix:<->(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X - Y # Where Y is castable to Numeric

multi sub infix:<->

multi sub infix:<->(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X - Y # Where X is castable to Numeric

multi sub infix:<*>

multi sub infix:<*>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X * Y

multi sub infix:<*>

multi sub infix:<*>(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X * Y # Where Y is castable to Numeric

multi sub infix:<*>

multi sub infix:<*>(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X * Y

multi sub infix:</>

multi sub infix:</>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X / Y

multi sub infix:</>

multi sub infix:</>(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X / Y # Where Y is castable to Numeric and read only

multi sub infix:</>

multi sub infix:</>(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X / Y # Where X is castable to Numeric and read only

multi sub infix:</>

multi sub infix:</>(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X / Y # Where Y is castable to Numeric and writable

multi sub infix:</>

multi sub infix:</>(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X / Y # Where X is castable to Numeric and writable

multi sub infix:<div>

multi sub infix:<div>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X div Y

multi sub infix:<div>

multi sub infix:<div>(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X div Y # Where Y is castable to Numeric and read only

multi sub infix:<div>

multi sub infix:<div>(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X div Y # Where X is castable to Numeric and read only

multi sub infix:<div>

multi sub infix:<div>(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X div Y # Where Y is castable to Numeric and writable

multi sub infix:<div>

multi sub infix:<div>(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X div Y # Where X is castable to Numeric and writable

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X == Y

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X == Y # Where Y is castable to Numeric and writable

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X == Y # Where Y is castable to Numeric and read only

multi sub infix:<==>

multi sub infix:<==>(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to Numeric and writable

multi sub infix:<==>

multi sub infix:<==>(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to Numeric and read only

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a where { ... },
    Date $b
) returns Mu

X == Y # Where X is castable to Numeric and read only

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Enumeration $b
) returns Mu

X == Y # Where LHS is AST and RHS is Enumeration

multi sub infix:<==>

multi sub infix:<==>(
    Enumeration $a,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to Numeric and writable

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Enumeration $b
) returns Mu

X != Y # Where Y is castable to Numeric and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X != Y # Where Y is castable to Numeric and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X != Y # Where Y is castable to Numeric and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to Numeric and writable

multi sub infix:<!=>

multi sub infix:<!=>(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to Numeric and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Enumeration $a,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to Numeric and writable

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X == Y X == Y # Where Y is Date and writable

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Date $b
) returns Mu

X == Y # Where Y is Date and read only

multi sub infix:<==>

multi sub infix:<==>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X == Y # Where X is Date and writable

multi sub infix:<==>

multi sub infix:<==>(
    Date $a,
    Red::AST $b
) returns Mu

X == Y # Where X is Date and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X != Y

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X != Y # Where Y is Date and writable

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Date $b
) returns Mu

X != Y # Where Y is Date and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X != Y # Where X is Date and writable

multi sub infix:<!=>

multi sub infix:<!=>(
    Date $a,
    Red::AST $b
) returns Mu

X != Y # Where X is Date and read only

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X eq Y # Where Y is castable to Str and writable

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X eq Y # Where Y is castable to Str and read only

multi sub infix:

multi sub infix:<eq>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X eq Y # Where X is castable to Str and writable

multi sub infix:

multi sub infix:<eq>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X eq Y # Where X is castable to Str and read only

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a where { ... },
    Date $b
) returns Mu

X eq Y # Where Y is any Red::AST that returns a DateTime

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a where { ... },
    Red::AST $b where { ... }
) returns Mu

X eq Y # Where both are AST that returns Str

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    Enumeration $b
) returns Mu

X eq Y # Where LHS is an AST and RHS is Enumeration

multi sub infix:

multi sub infix:<ne>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X ne Y # Where Y is castable to Str and writable

multi sub infix:

multi sub infix:<ne>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X ne Y # Where Y is castable to Str and read only

multi sub infix:

multi sub infix:<ne>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X ne Y # Where X is castable to Str and writable

multi sub infix:

multi sub infix:<ne>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X ne Y # Where X is castable to Str and read only

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X < Y # Where Y is any Red::AST that returns a Numeric

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X < Y # Where Y is castable to Numeric and writable

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X < Y # Where Y is castable to Numeric and read only

multi sub infix:«<»

multi sub infix:«<»(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X < Y # Where X is castable to Numeric and writable

multi sub infix:«<»

multi sub infix:«<»(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X < Y # Where X is castable to Numeric and read only

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X > Y # Where Y is any Red::AST that returns a Numeric

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X > Y # Where Y is castable to Numeric and writable

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X > Y # Where Y is castable to Numeric and read only

multi sub infix:«>»

multi sub infix:«>»(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X > Y # Where X is castable to Numeric and writable

multi sub infix:«>»

multi sub infix:«>»(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X > Y # Where X is castable to Numeric and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X <= Y # Where Y is any Red::AST that returns a Numeric

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X <= Y # Where Y is castable to Numeric and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X <= Y # Where Y is castable to Numeric and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X <= Y # Where X is castable to Numeric and writable

multi sub infix:«<=»

multi sub infix:«<=»(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X <= Y # Where X is castable to Numeric and read only

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X >= Y # Where Y is any Red::AST that returns a Numeric

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a,
    Numeric(Any) $b is rw
) returns Mu

X >= Y # Where Y is castable to Numeric and writable

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a,
    Numeric(Any) $b
) returns Mu

X >= Y # Where Y is castable to Numeric and read only

multi sub infix:«>=»

multi sub infix:«>=»(
    Numeric(Any) $a is rw,
    Red::AST $b
) returns Mu

X >= Y # Where X is castable to Numeric and writable

multi sub infix:«>=»

multi sub infix:«>=»(
    Numeric(Any) $a,
    Red::AST $b
) returns Mu

X >= Y # Where X is castable to Numeric and read only

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    DateTime(Any) $b is rw
) returns Mu

X == Y # Where Y is castable to DateTime and writable

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    DateTime(Any) $b
) returns Mu

X == Y # Where Y is castable to DateTime and read only

multi sub infix:<==>

multi sub infix:<==>(
    DateTime(Any) $a is rw,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to DateTime and writable

multi sub infix:<==>

multi sub infix:<==>(
    DateTime(Any) $a,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to DateTime and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    DateTime(Any) $b is rw
) returns Mu

X != Y # Where Y is castable to DateTime and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    DateTime(Any) $b
) returns Mu

X != Y # Where Y is castable to DateTime and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    DateTime(Any) $a is rw,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to DateTime and writable

multi sub infix:<!=>

multi sub infix:<!=>(
    DateTime(Any) $a,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to DateTime and read only

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X < Y # Where Y is any Red::AST that returns a DateTime

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a,
    DateTime(Any) $b is rw
) returns Mu

X < Y # Where Y is DateTime and writable

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a,
    DateTime(Any) $b
) returns Mu

X < Y # Where Y is DateTime and read only

multi sub infix:«<»

multi sub infix:«<»(
    DateTime(Any) $a is rw,
    Red::AST $b
) returns Mu

X < Y # Where X is DateTime and writable

multi sub infix:«<»

multi sub infix:«<»(
    DateTime(Any) $a,
    Red::AST $b
) returns Mu

X < Y # Where X is DateTime and read only

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X > Y # Where Y is any Red::AST that returns a DateTime

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a,
    DateTime(Any) $b is rw
) returns Mu

X > Y # Where Y is DateTime and writable

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a,
    DateTime(Any) $b
) returns Mu

X > Y # Where Y is DateTime and read only

multi sub infix:«>»

multi sub infix:«>»(
    DateTime(Any) $a is rw,
    Red::AST $b
) returns Mu

X > Y # Where X is DateTime and writable

multi sub infix:«>»

multi sub infix:«>»(
    DateTime $a,
    Red::AST $b
) returns Mu

X > Y # Where X is DateTime and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X <= Y # Where Y is any Red::AST that returns a DateTime

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a,
    DateTime(Any) $b is rw
) returns Mu

X <= Y # Where Y is DateTime and writable

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a,
    DateTime(Any) $b
) returns Mu

X <= Y # Where Y is DateTime and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X <= Y # Where X is DateTime and writable

multi sub infix:«<=»

multi sub infix:«<=»(
    DateTime(Any) $a,
    Red::AST $b
) returns Mu

X <= Y # Where X is DateTime and read only

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X >= Y # Where Y is any Red::AST that returns a DateTime

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a,
    DateTime(Any) $b is rw
) returns Mu

X >= Y # Where Y is DateTime and writable

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a,
    DateTime(Any) $b
) returns Mu

X >= Y # Where Y is DateTime and read only

multi sub infix:«>=»

multi sub infix:«>=»(
    DateTime(Any) $a is rw,
    Red::AST $b
) returns Mu

X >= Y # Where X is DateTime and writable

multi sub infix:«>=»

multi sub infix:«>=»(
    DateTime(Any) $a,
    Red::AST $b
) returns Mu

X >= Y # Where X is DateTime and read only

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Date(Any) $b is rw
) returns Mu

X == Y # Where Y is castable to Date and writable

multi sub infix:<==>

multi sub infix:<==>(
    Red::AST $a,
    Date(Any) $b
) returns Mu

X == Y # Where Y is castable to Date and read only

multi sub infix:<==>

multi sub infix:<==>(
    Date(Any) $a is rw,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to Date and writable

multi sub infix:<==>

multi sub infix:<==>(
    Date(Any) $a,
    Red::AST $b
) returns Mu

X == Y # Where X is castable to Date and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Date(Any) $b is rw
) returns Mu

X != Y # Where Y is castable to Date and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Red::AST $a,
    Date(Any) $b
) returns Mu

X != Y # Where Y is castable to Date and read only

multi sub infix:<!=>

multi sub infix:<!=>(
    Date(Any) $a is rw,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to Date and writable

multi sub infix:<!=>

multi sub infix:<!=>(
    Date(Any) $a,
    Red::AST $b
) returns Mu

X != Y # Where X is castable to Date and read only

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X < Y # Where Y is any Red::AST that returns a Date

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a,
    Date $b is rw
) returns Mu

X < Y # Where Y is Date and writable

multi sub infix:«<»

multi sub infix:«<»(
    Red::AST $a,
    Date $b
) returns Mu

X < Y # Where Y is Date and read only

multi sub infix:«<»

multi sub infix:«<»(
    Date $a is rw,
    Red::AST $b
) returns Mu

X < Y # Where X is Date and writable

multi sub infix:«<»

multi sub infix:«<»(
    Date $a,
    Red::AST $b
) returns Mu

X < Y # Where X is Date and read only

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X > Y # Where Y is any Red::AST that returns a Date

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a,
    Date $b is rw
) returns Mu

X > Y # Where Y is Date and writable

multi sub infix:«>»

multi sub infix:«>»(
    Red::AST $a,
    Date $b
) returns Mu

X > Y # Where Y is Date and read only

multi sub infix:«>»

multi sub infix:«>»(
    Date $a is rw,
    Red::AST $b
) returns Mu

X > Y # Where X is Date and writable

multi sub infix:«>»

multi sub infix:«>»(
    Date $a,
    Red::AST $b
) returns Mu

X > Y # Where X is Date and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X <= Y # Where Y is any Red::AST that returns a Date

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a,
    Date $b is rw
) returns Mu

X <= Y # Where Y is Date and writable

multi sub infix:«<=»

multi sub infix:«<=»(
    Red::AST $a,
    Date $b
) returns Mu

X <= Y # Where Y is Date and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Date $a is rw,
    Red::AST $b
) returns Mu

X <= Y # Where X is Date and read only

multi sub infix:«<=»

multi sub infix:«<=»(
    Date $a,
    Red::AST $b
) returns Mu

X <= Y # Where X is Date and read only

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a where { ... },
    Red::AST $b
) returns Mu

X >= Y # Where Y is any Red::AST that returns a Date

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a,
    Date $b is rw
) returns Mu

X >= Y # Where Y is Date and writable

multi sub infix:«>=»

multi sub infix:«>=»(
    Red::AST $a,
    Date $b
) returns Mu

X >= Y # Where Y is Date and read only

multi sub infix:«>=»

multi sub infix:«>=»(
    Date $a is rw,
    Red::AST $b
) returns Mu

X >= Y # Where X is Date and writable

multi sub infix:«>=»

multi sub infix:«>=»(
    Date $a,
    Red::AST $b
) returns Mu

X >= Y # Where X is Date and read only

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    DateTime $b is rw
) returns Mu

X eq Y # Where Y is castable to DateTime and writable

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    DateTime $b
) returns Mu

X eq Y # Where Y is castable to DateTime and read only

multi sub infix:

multi sub infix:<eq>(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X eq Y # Where X is castable to DateTime and writable

multi sub infix:

multi sub infix:<eq>(
    DateTime $a,
    Red::AST $b
) returns Mu

X eq Y # Where X is castable to DateTime and read only

multi sub infix:

multi sub infix:<ne>(
    Red::AST $a,
    DateTime $b is rw
) returns Mu

X ne Y # Where Y is castable to DateTime and writable

multi sub infix:

multi sub infix:<ne>(
    Red::AST $a,
    DateTime $b
) returns Mu

X ne Y # Where Y is castable to DateTime and read only

multi sub infix:

multi sub infix:<ne>(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X ne Y # Where X is castable to DateTime and writable

multi sub infix:

multi sub infix:<ne>(
    DateTime $a,
    Red::AST $b
) returns Mu

X ne Y # Where X is castable to DateTime and read only

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    DateTime $b is rw
) returns Mu

X lt Y # Where Y is castable to DateTime and writable

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    DateTime $b
) returns Mu

X lt Y # Where Y is castable to DateTime and read only

multi sub infix:

multi sub infix:<lt>(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X lt Y # Where X is castable to DateTime and writable

multi sub infix:

multi sub infix:<lt>(
    DateTime $a,
    Red::AST $b
) returns Mu

X lt Y # Where X is castable to DateTime and read only

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    DateTime $b is rw
) returns Mu

X gt Y # Where Y is castable to DateTime and writable

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    DateTime $b
) returns Mu

X gt Y # Where Y is castable to DateTime and read only

multi sub infix:

multi sub infix:<gt>(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X gt Y # Where X is castable to DateTime and writable

multi sub infix:

multi sub infix:<gt>(
    DateTime $a,
    Red::AST $b
) returns Mu

X gt Y # Where X is castable to DateTime and read only

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    DateTime $b is rw
) returns Mu

X le Y # Where Y is castable to DateTime and writable

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    DateTime $b
) returns Mu

X le Y # Where Y is castable to DateTime and read only

multi sub infix:

multi sub infix:<le>(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X le Y # Where X is castable to DateTime and writable

multi sub infix:

multi sub infix:<le>(
    DateTime $a,
    Red::AST $b
) returns Mu

X le Y # Where X is castable to DateTime and read only

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    DateTime $b is rw
) returns Mu

X ge Y # Where Y is castable to DateTime and writable

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    DateTime $b
) returns Mu

X ge Y # Where Y is castable to DateTime and read only

multi sub infix:

multi sub infix:<ge>(
    DateTime $a is rw,
    Red::AST $b
) returns Mu

X ge Y # Where X is castable to DateTime and writable

multi sub infix:

multi sub infix:<ge>(
    DateTime $a,
    Red::AST $b
) returns Mu

X ge Y # Where X is castable to DateTime and read only

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X eq Y # Where Y is castable to Date and writable

multi sub infix:

multi sub infix:<eq>(
    Red::AST $a,
    Date $b
) returns Mu

X eq Y # Where Y is castable to Date and read only

multi sub infix:

multi sub infix:<eq>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X eq Y # Where X is castable to Date and writable

multi sub infix:

multi sub infix:<eq>(
    Date $a,
    Red::AST $b
) returns Mu

X eq Y # Where X is castable to Date and read only

multi sub infix:

multi sub infix:<ne>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X ne Y # Where Y is castable to Date and writable

multi sub infix:

multi sub infix:<ne>(
    Red::AST $a,
    Date $b
) returns Mu

X ne Y # Where Y is castable to Date and read only

multi sub infix:

multi sub infix:<ne>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X ne Y # Where X is castable to Date and writable

multi sub infix:

multi sub infix:<ne>(
    Date $a,
    Red::AST $b
) returns Mu

X ne Y # Where X is castable to Date and read only

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X lt Y # Where Y is castable to Date and writable

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    Date $b
) returns Mu

X lt Y # Where Y is castable to Date and read only

multi sub infix:

multi sub infix:<lt>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X lt Y # Where X is castable to Date and writable

multi sub infix:

multi sub infix:<lt>(
    Date $a,
    Red::AST $b
) returns Mu

X lt Y # Where X is castable to Date and read only

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X gt Y # Where Y is castable to Date and writable

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    Date $b
) returns Mu

X gt Y # Where Y is castable to Date and read only

multi sub infix:

multi sub infix:<gt>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X gt Y # Where X is castable to Date and writable

multi sub infix:

multi sub infix:<gt>(
    Date $a,
    Red::AST $b
) returns Mu

X gt Y # Where X is castable to Date and read only

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X le Y # Where Y is castable to Date and writable

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    Date $b
) returns Mu

X le Y # Where Y is castable to Date and read only

multi sub infix:

multi sub infix:<le>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X le Y # Where X is castable to Date and writable

multi sub infix:

multi sub infix:<le>(
    Date $a,
    Red::AST $b
) returns Mu

X le Y # Where X is castable to Date and read only

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    Date $b is rw
) returns Mu

X ge Y # Where Y is castable to Date and writable

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    Date $b
) returns Mu

X ge Y # Where Y is castable to Date and read only

multi sub infix:

multi sub infix:<ge>(
    Date $a is rw,
    Red::AST $b
) returns Mu

X ge Y # Where X is castable to Date and writable

multi sub infix:

multi sub infix:<ge>(
    Date $a,
    Red::AST $b
) returns Mu

X ge Y # Where X is castable to Date and read only

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X lt Y

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X lt Y # Where Y is castable to Str and writable

multi sub infix:

multi sub infix:<lt>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X lt Y # Where Y is castable to Str and read only

multi sub infix:

multi sub infix:<lt>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X lt Y # Where X is castable to Str and writable

multi sub infix:

multi sub infix:<lt>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X lt Y # Where X is castable to Str and read only

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X gt Y

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X gt Y # Where Y is castable to Str and writable

multi sub infix:

multi sub infix:<gt>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X gt Y # Where Y is castable to Str and read only

multi sub infix:

multi sub infix:<gt>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X gt Y # Where X is castable to Str and writable

multi sub infix:

multi sub infix:<gt>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X gt Y # Where X is castable to Str and read only

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X le Y

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X le Y # Where Y is castable to Str and writable

multi sub infix:

multi sub infix:<le>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X le Y # Where Y is castable to Str and read only

multi sub infix:

multi sub infix:<le>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X le Y # Where X is castable to Str and writable

multi sub infix:

multi sub infix:<le>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X le Y # Where X is castable to Str and read only

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X ge Y

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X ge Y # Where Y is castable to Str and writable

multi sub infix:

multi sub infix:<ge>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X ge Y # Where Y is castable to Str and read only

multi sub infix:

multi sub infix:<ge>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X ge Y # Where X is castable to Str and writable

multi sub infix:

multi sub infix:<ge>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X ge Y # Where X is castable to Str and read only

multi sub infix:<%>

multi sub infix:<%>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X % Y

multi sub infix:<%>

multi sub infix:<%>(
    Red::AST $a,
    Int(Any) $b is rw
) returns Mu

X % Y # Where X is castable to Int and writable

multi sub infix:<%>

multi sub infix:<%>(
    Red::AST $a,
    Int(Any) $b
) returns Mu

X % Y # Where Y is castable to Int and read only

multi sub infix:<%>

multi sub infix:<%>(
    Int(Any) $a is rw,
    Red::AST $b
) returns Mu

X % Y # Where X is castable to Int and writable

multi sub infix:<%>

multi sub infix:<%>(
    Int(Any) $a,
    Red::AST $b
) returns Mu

X % Y # Where X is castable to Int and read only

multi sub infix:<%%>

multi sub infix:<%%>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X %% Y

multi sub infix:<%%>

multi sub infix:<%%>(
    Red::AST $a,
    Int(Any) $b is rw
) returns Mu

X %% Y # Where Y is castable to Int and writable

multi sub infix:<%%>

multi sub infix:<%%>(
    Red::AST $a,
    Int(Any) $b
) returns Mu

X %% Y # Where Y is castable to Int and read only

multi sub infix:<%%>

multi sub infix:<%%>(
    Int(Any) $a is rw,
    Red::AST $b
) returns Mu

X %% Y # Where X is castable to Int

multi sub infix:<%%>

multi sub infix:<%%>(
    Int(Any) $a,
    Red::AST $b
) returns Mu

X %% Y # Where X is read only

multi sub infix:<~>

multi sub infix:<~>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X ~ Y

multi sub infix:<~>

multi sub infix:<~>(
    Red::AST $a,
    Str(Any) $b is rw
) returns Mu

X ~ Y Where Y is castable to Str and writable

multi sub infix:<~>

multi sub infix:<~>(
    Red::AST $a,
    Str(Any) $b
) returns Mu

X ~ Y Where Y is castable to Str and read only

multi sub infix:<~>

multi sub infix:<~>(
    Str(Any) $a is rw,
    Red::AST $b
) returns Mu

X ~ Y # Where X is castable to Str and writable

multi sub infix:<~>

multi sub infix:<~>(
    Str(Any) $a,
    Red::AST $b
) returns Mu

X ~ Y # Where X is castable to Str and read only

multi sub prefix:

multi sub prefix:<not>(
    Red::AST $a
) returns Mu

not X # Where X is read only

multi sub prefix:

multi sub prefix:<not>(
    Red::AST $a is rw
) returns Mu

not X

multi sub prefix:<!>

multi sub prefix:<!>(
    Red::AST $a
) returns Mu

!X

multi sub prefix:

multi sub prefix:<not>(
    Red::AST::In $a
) returns Mu

not X # Where X is a in

multi sub prefix:<!>

multi sub prefix:<!>(
    Red::AST::In $a
) returns Mu

!X # Where X is a in

multi sub prefix:

multi sub prefix:<so>(
    Red::AST $a
) returns Mu

so X

multi sub prefix:<?>

multi sub prefix:<?>(
    Red::AST $a
) returns Mu

?X

multi sub infix:

multi sub infix:<AND>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X AND Y

multi sub infix:

multi sub infix:<OR>(
    Red::AST $a,
    Red::AST $b
) returns Mu

X OR Y

multi sub infix:<∪>

multi sub infix:<∪>(
    Red::ResultSeq $a,
    Red::ResultSeq $b
) returns Mu

X ∪ Y # Where X and Y are ResultSeqs

multi sub infix:<(|)>

multi sub infix:<(|)>(
    Red::ResultSeq $a,
    Red::ResultSeq $b
) returns Mu

X (	) Y # Where X and Y are ResultSeqs

multi sub infix:<∩>

multi sub infix:<∩>(
    Red::ResultSeq $a,
    Red::ResultSeq $b
) returns Mu

X ∩ Y # Where X and Y are ResultSeqs

multi sub infix:<(&)>

multi sub infix:<(&)>(
    Red::ResultSeq $a,
    Red::ResultSeq $b
) returns Mu

X (&) Y # Where X and Y are ResultSeqs

multi sub infix:<⊖>

multi sub infix:<⊖>(
    Red::ResultSeq $a,
    Red::ResultSeq $b
) returns Mu

X ⊖ Y # Where X and Y are ResultSeqs

multi sub infix:<(-)>

multi sub infix:<(-)>(
    Red::ResultSeq $a,
    Red::ResultSeq $b
) returns Mu

X (-) Y # Where X and Y are ResultSeqs

multi sub infix:

multi sub infix:<in>(
    Red::AST $a,
    Red::ResultSeq:D $b
) returns Mu

X in Y # Where Y is a ResultSeq

multi sub infix:<⊂>

multi sub infix:<⊂>(
    Red::AST $a,
    Red::ResultSeq $b
) returns Mu

X ⊂ Y # Where Y is a ResultSeq

multi sub infix:«(<)»

multi sub infix:«(<)»(
    Red::AST $a,
    Red::ResultSeq $b
) returns Mu

X (<) Y # Where Y is a ResultSeq

multi sub infix:<⊃>

multi sub infix:<⊃>(
    Red::AST $a,
    Red::ResultSeq $b
) returns Mu

X ⊃ Y # Where Y is a ResultSeq

multi sub infix:«(>)»

multi sub infix:«(>)»(
    Red::AST $a,
    Red::ResultSeq $b
) returns Mu

X (>) Y # Where Y is a ResultSeq

multi sub infix:

multi sub infix:<in>(
    Red::AST $a,
    $b where { ... }
) returns Mu

X in Y # Where Y is a positional but not a ResultSeq

multi sub infix:<⊂>

multi sub infix:<⊂>(
    Red::AST $a,
    $b where { ... }
) returns Mu

X ⊂ Y # Where Y is a positional but not a ResultSeq

multi sub infix:«(<)»

multi sub infix:«(<)»(
    Red::AST $a,
    $b where { ... }
) returns Mu

X (<) Y # Where Y is a positional but not a ResultSeq

multi sub infix:<⊃>

multi sub infix:<⊃>(
    Red::AST $a,
    $b where { ... }
) returns Mu

X ⊃ Y # Where Y is a positional but not a ResultSeq

multi sub infix:«(>)»

multi sub infix:«(>)»(
    Red::AST $a,
    $b where { ... }
) returns Mu

X (>) Y # Where Y is a positional but not a ResultSeq

multi sub infix:

multi sub infix:<in>(
    Red::AST $a,
    Red::AST::Select $b
) returns Mu

X in Y # where Y is a select

multi sub infix:<⊂>

multi sub infix:<⊂>(
    Red::AST $a,
    Red::AST::Select $b
) returns Mu

X ⊂ Y # where Y is a select

multi sub infix:«(<)»

multi sub infix:«(<)»(
    Red::AST $a,
    Red::AST::Select $b
) returns Mu

X (<) Y # where Y is a select

multi sub infix:<⊃>

multi sub infix:<⊃>(
    Red::AST $a,
    Red::AST::Select $b
) returns Mu

X ⊃ Y # where Y is a select

multi sub infix:«(>)»

multi sub infix:«(>)»(
    Red::AST $a,
    Red::AST::Select $b
) returns Mu

X (>) Y # Where Y is a select