Since the range method already works fine, I donâ€™t imagine it would ever be accepted into the Standard Library.

That said, it is easy to implement yourself in a libraryâ€”well *almost*. In theory all the building blocks are available. The only hitch is that the Standard Library gets in the way by already defining the comparison operators with no associativity. You cannot shadow a Standard Library operator with your own, nor can you opt out of importing the Standard Library to evade the name collision.

You can get close if you are willing to put up with parentheses:

```
func <(lhs: Int, rhs: Int) -> (veracity: Bool, checkedValue: Int) {
return ((lhs < rhs) as Bool, rhs)
}
func <=(lhs: (veracity: Bool, checkedValue: Int), rhs: Int) -> Bool {
return lhs.veracity && (lhs.checkedValue <= rhs)
}
let numberOfApples = 5
if (0 < numberOfApples) <= 10 {
// ...
}
```

Or you can move to your own operators in order to drop the parentheses. Hurray for Unicode!

```
precedencegroup Inequality {
lowerThan: ComparisonPrecedence
associativity: left
}
infix operator â‰¤: Inequality
func <(lhs: Int, rhs: Int) -> (veracity: Bool, checkedValue: Int) {
return ((lhs < rhs) as Bool, rhs)
}
func â‰¤(lhs: (veracity: Bool, checkedValue: Int), rhs: Int) -> Bool {
return lhs.veracity && (lhs.checkedValue <= rhs)
}
let numberOfApples = 5
if 0 < numberOfApples â‰¤ 10 {
// ...
}
```

(Unicode can only properly help you fix `x < y â‰¤ z`

, `x â‰¤ y < z`

, and `x â‰¤ y â‰¤ z`

. You cannot express `x < y < z`

unless you invent some more exotic replacement characterâ€”such as the â€śprecedesâ€ť symbol: `â‰ş`

.)