feat: include Comparable module, add test for it

Author: initdc

spec/option_spec.cr

@@ -224,4 +224,15 @@ describe Option do
     Option.from!(env_user).should eq(Some[%x(whoami).chomp])
     Option.from!(env_not_existing).should eq(None(String)[])
   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

@@ -233,4 +233,23 @@ describe Result do
     Result.from_or!(false, env_user).should eq(Ok(String, Bool)[%x(whoami).chomp])
     Result.from_or!(false, env_not_existing).should eq(Err(String, Bool)[false])
   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 %}
 
@@ -285,6 +287,23 @@ abstract struct Option(T)
   rescue
     None(T).new
   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 %}
 
@@ -290,6 +292,23 @@ abstract struct Result(T, E)
   rescue
     Err(T, E).new(error)
   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)