### ----------------------------------------------------
### -- Red
### -- Licenses: Artistic-2.0
### -- Authors: Fernando Correa de Oliveira
### -- File: docs/api/Red/Operators.md
### ----------------------------------------------------
### -- Chunk 1 of 2
Red::Operators
--------------

### multi sub prefix:<-->

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

--X

### multi sub prefix:<++>

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

++X

### multi sub postfix:<-->

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

X--

### multi sub postfix:<++>

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

X++

### multi sub prefix:<->

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

-X

### multi sub prefix:<+>

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

+X

### multi sub infix:<+>

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

X + Y

### multi sub infix:<+>

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

X + Y # Where Y is castable to Numeric

### multi sub infix:<+>

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

X + Y # Where X is castable to Numeric

### multi sub infix:<->

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

X - Y

### multi sub infix:<->

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

X - Y # Where Y is castable to Numeric

### multi sub infix:<->

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

X - Y # Where X is castable to Numeric

### multi sub infix:<*>

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

X * Y

### multi sub infix:<*>

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

X * Y # Where Y is castable to Numeric

### multi sub infix:<*>

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

X * Y

### multi sub infix:</>

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

X / Y

### multi sub infix:</>

```raku
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:</>

```raku
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:</>

```raku
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:</>

```raku
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>

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

X div Y

### multi sub infix:<div>

```raku
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>

```raku
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>

```raku
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>

```raku
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:<eqv>

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

X eqv Y

### multi sub infix:<==>

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

X == Y

### multi sub infix:<==>

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

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

### multi sub infix:<==>

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

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

### multi sub infix:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<==>

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

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

### multi sub infix:<==>

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

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

### multi sub infix:<!=>

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

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

### multi sub infix:<!=>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:<!=>

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

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

### multi sub infix:<==>

```raku
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:<==>

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

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

### multi sub infix:<==>

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

X == Y # Where X is Date and writable

### multi sub infix:<==>

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

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

### multi sub infix:<!=>

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

X != Y

### multi sub infix:<!=>

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

X != Y # Where Y is Date and writable

### multi sub infix:<!=>

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

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

### multi sub infix:<!=>

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

X != Y # Where X is Date and writable

### multi sub infix:<!=>

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

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

### multi sub infix:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<ne>

```raku
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:<ne>

```raku
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:<ne>

```raku
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:<ne>

```raku
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:«<»

```raku
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:«<»

```raku
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:«<»

```raku
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:«<»

```raku
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:«<»

```raku
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:«>»

```raku
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:«>»

```raku
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:«>»

```raku
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:«>»

```raku
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:«>»

```raku
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:«<=»

```raku
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:«<=»

```raku
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:«<=»

```raku
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:«<=»

```raku
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:«<=»

```raku
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:«>=»

```raku
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:«>=»

```raku
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:«>=»

```raku
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:«>=»

```raku
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:«>=»

```raku
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:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:«<»

```raku
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:«<»

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

X < Y # Where Y is DateTime and writable

### multi sub infix:«<»

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

X < Y # Where Y is DateTime and read only

### multi sub infix:«<»

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

X < Y # Where X is DateTime and writable

### multi sub infix:«<»

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

X < Y # Where X is DateTime and read only

### multi sub infix:«>»

```raku
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:«>»

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

X > Y # Where Y is DateTime and writable

### multi sub infix:«>»

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

X > Y # Where Y is DateTime and read only

### multi sub infix:«>»

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

X > Y # Where X is DateTime and writable

### multi sub infix:«>»

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

X > Y # Where X is DateTime and read only

### multi sub infix:«<=»

```raku
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:«<=»

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

X <= Y # Where Y is DateTime and writable

### multi sub infix:«<=»

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

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

### multi sub infix:«<=»

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

X <= Y # Where X is DateTime and writable

### multi sub infix:«<=»

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

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

### multi sub infix:«>=»

```raku
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:«>=»

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

X >= Y # Where Y is DateTime and writable

### multi sub infix:«>=»

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

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

### multi sub infix:«>=»

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

X >= Y # Where X is DateTime and writable

### multi sub infix:«>=»

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

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

### multi sub infix:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<==>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:<!=>

```raku
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:«<»

```raku
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:«<»

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

X < Y # Where Y is Date and writable

### multi sub infix:«<»

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

X < Y # Where Y is Date and read only

### multi sub infix:«<»

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

X < Y # Where X is Date and writable

### multi sub infix:«<»

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

X < Y # Where X is Date and read only

### multi sub infix:«>»

```raku
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:«>»

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

X > Y # Where Y is Date and writable

### multi sub infix:«>»

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

X > Y # Where Y is Date and read only

### multi sub infix:«>»

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

X > Y # Where X is Date and writable

### multi sub infix:«>»

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

X > Y # Where X is Date and read only

### multi sub infix:«<=»

```raku
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:«<=»

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

X <= Y # Where Y is Date and writable

### multi sub infix:«<=»

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

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

### multi sub infix:«<=»

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

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

### multi sub infix:«<=»

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

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

### multi sub infix:«>=»

```raku
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:«>=»

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

X >= Y # Where Y is Date and writable

### multi sub infix:«>=»

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

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

### multi sub infix:«>=»

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

X >= Y # Where X is Date and writable

### multi sub infix:«>=»

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

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

### multi sub infix:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<eq>

```raku
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:<ne>

```raku
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:<ne>

```raku
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:<ne>

```raku
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:<ne>

```raku
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:<lt>

```raku
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:<lt>

```raku
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:<lt>

```raku
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:<lt>

```raku
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:<gt>

```raku
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:<gt>

```raku
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:<gt>

```raku
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:<gt>

```raku
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:<le>

```raku
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:<le>

```raku
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:<le>

```raku
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:<le>

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

X