In Ruby, how do <=> and Comparable give a Temperature class <, ==, between? and clamp, and what should <=> return for incomparable values?

## The spaceship operator `<=>` is Ruby's general comparison method. `a <=> b` returns: - a **negative** Integer if `a` is less than `b`, - **`0`** if they are equal, - a **positive** Integer if `a` is greater, - **`nil`** if the two cannot be compared at all. Core classes define it: `1 <=> 2` is `-1`, `"b" <=> "a"` is `1`, and `1 <=> "a"` is `nil`. The default on `Object` returns `0` for the same object (or `==` objects) and `nil` otherwise. ## Comparable builds the rest `Comparable` is a module that implements the comparison operators on top of your `<=>`: ```ruby class Temperature include Comparable attr_reader :degrees def initialize(degrees) @degrees = degrees end def <=>(other) return nil unless other.is_a?(Temperature) degrees <=> other.degrees end end hot = Temperature.new(30) mild = Temperature.new(20) hot > mild # => true hot == Temperature.new(30) # => true hot.between?(Temperature.new(0), mild) # => false hot.clamp(Temperature.new(0), mild).degrees # => 20 ``` | Method from Comparable | Defined as | |---|---| | `<`, `<=`, `>=`, `>` | the sign of `self <=> other` | | `==` | `true` if same object or `<=>` returns `0`; `false` if `<=>` is `nil` | | `between?(min, max)` | not below `min` and not above `max`, both inclusive | | `clamp(min, max)` | `min` if below, `max` if above, otherwise `self` | | `clamp(range)` | the same with `range.begin` and `range.end` | Note that `hot.clamp(...)` returns the **bound object itself** when `hot` is out of range, here the `mild` object, not a new Temperature. ## Returning nil, and what it triggers Returning `nil` for a foreign type is part of the contract, and the two kinds of operator react differently: 1. The ordering operators `<`, `<=`, `>`, `>=` (and `between?`, `clamp`) raise **`ArgumentError`**, with a message such as `comparison of Temperature with 5 failed`. 2. `==` returns **`false`**, so `hot == 5` is simply false rather than an error. Raising an exception from `<=>` instead, or returning `0` or `-1` for unrelated objects, breaks both of those behaviours and makes mixed collections misbehave in confusing ways. ## between? is inclusive `between?(min, max)` returns true when the receiver is equal to either bound, because it only rejects values strictly below `min` or strictly above `max`. So `mild.between?(mild, hot)` is `true`. If you need a half-open check, compare explicitly with `>=` and `<`, or use a Range and its own methods, which is a separate topic. Both `between?` and `clamp` call your `<=>` against each bound, so a `<=>` that returns `nil` for a bound of the wrong type makes them raise `ArgumentError` just like `<` does. ## Edge cases of clamp - `clamp(min, max)` raises `ArgumentError` if `min` is greater than `max`. - `clamp(range)` accepts an endless or beginless range: `20.clamp(..15)` is `15`. - An **exclusive** range with an end, like `0...100`, raises `ArgumentError` (cannot clamp with an exclusive range), because there is no largest value below the end to return. - A `nil` bound means unbounded on that side. ## What Comparable does not give you - It does **not** define `eql?` or `hash`, so two equal Temperatures are still different `Hash` keys and are not collapsed by `uniq` until you override those two as well. - If the class already defines its own `==`, that one is used, because the class's method is found before the module's. - Sorting with `sort` also relies on `<=>`, but works without `Comparable`; how sorting uses it is a topic of its own. ## Why interviewers ask it It checks that a candidate uses Ruby's mechanism instead of hand-writing five operators, knows the `nil` return for incomparable values and its consequences, and does not assume that `Comparable`'s `==` also makes objects equal as hash keys.