feat: include Comparable module, add test for it

Author: initdc

spec/option_spec.cr

@@ -209,4 +209,15 @@ describe Option do
     y4 = None(Int32)[]
     x4.xor(y4).should eq(None(Int32)[])
   end
+
+  it "<=>" do
+    a = None(Int32)[]
+    b = Some[0]
+    c = Some[1]
+
+    (a < b).should be_true
+    (b < c).should be_true
+
+    expect_raises(Option::Uncomparable) { a <=> 0 }
+  end
 end

spec/result_spec.cr

@@ -217,4 +217,23 @@ describe Result do
     y = Err(Int32, String)["foo"]
     y.unwrap_or_else { |e| e.size }.should eq(3)
   end
+
+  it "<=>" do
+    x1 = Ok(Int32, String)[1]
+    y1 = Err(Int32, String)["error"]
+
+    (x1 < y1).should be_true
+
+    x2 = Ok(Int32, String)[0]
+    y2 = Ok(Int32, String)[1]
+
+    (x2 < y2).should be_true
+
+    x3 = Err(Int32, Int32)[0]
+    y3 = Err(Int32, Int32)[1]
+
+    (x3 < y3).should be_true
+
+    expect_raises(Result::Uncomparable) { x1 <=> 0 }
+  end
 end

src/option.cr

@@ -3,6 +3,8 @@ require "./result"
 abstract struct Option(T)
   class UnwrapNone < Exception; end
 
+  class Uncomparable < Exception; end
+
   macro inherited
     {% type = @type.name(generic_args: false).stringify %}
 
@@ -265,6 +267,23 @@ abstract struct Option(T)
       end
     end
   end
+
+  include Comparable(self)
+
+  def <=>(other) : Int32
+    case {self, other}
+    when {Some, Some}
+      self.unwrap <=> other.unwrap
+    when {Some, None}
+      1
+    when {None, Some}
+      -1
+    when {None, None}
+      0
+    else
+      raise Uncomparable.new("Cannot compare Option with #{other.class}")
+    end
+  end
 end
 
 struct Some(T) < Option(T)

src/result.cr

@@ -3,6 +3,8 @@ abstract struct Result(T, E)
 
   class UnwrapErrOnOk < Exception; end
 
+  class Uncomparable < Exception; end
+
   macro inherited
     {% type = @type.name(generic_args: false).stringify %}
 
@@ -270,6 +272,23 @@ abstract struct Result(T, E)
     {% end %}
     end
   end
+
+  include Comparable(self)
+
+  def <=>(other) : Int32
+    case {self, other}
+    when {Ok, Ok}
+      self.unwrap <=> other.unwrap
+    when {Ok, Err}
+      -1
+    when {Err, Ok}
+      1
+    when {Err, Err}
+      self.unwrap_err <=> other.unwrap_err
+    else
+      raise Uncomparable.new("Cannot compare Result with #{other.class}")
+    end
+  end
 end
 
 struct Ok(T, E) < Result(T, E)