feat: include Comparable module, add test for it

Author: initdc

spec/option_spec.cr

@@ -238,4 +238,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]
+    d = Some[1]
+
+    (a < b).should be_true
+    (b < c).should be_true
+    (c == d).should be_true
+  end
 end

spec/result_spec.cr

@@ -236,4 +236,19 @@ describe Result do
     Result.from_or!(-> { ENV["USER"] }, false).should eq(Ok(String, Bool)[%x(whoami).chomp])
     Result.from_or!(-> { ENV["NOT_EXISTING"] }, false).should eq(Err(String, Bool)[false])
   end
+
+  it "<=>" do
+    x1 = Ok(Int32, String)[1]
+    y1 = Err(Int32, String)["error"]
+    (x1 < y1).should be_true
+    (y1 < x1).should be_false
+
+    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
+  end
 end

src/option.cr

@@ -5,6 +5,8 @@ abstract struct Option(T)
 
   class UnwrapNone < Exception; end
 
+  class Uncomparable < Exception; end
+
   macro inherited
     {% type = @type.name(generic_args: false) %}
 
@@ -287,14 +289,33 @@ abstract struct Option(T)
   rescue
     None(T).new
   end
+
+  include Comparable(self)
+
+  def <=>(other : Option(T)) : Int32
+    case {self, other}
+    when {Some, None}
+      1
+    when {None, Some}
+      -1
+    when {None, None}
+      0
+    else
+      {% if T.has_method?(:<=>) %}
+        self.unwrap <=> other.unwrap
+      {% else %}
+        0
+      {% end %}
+    end
+  end
 end
 
 struct Some(T) < Option(T)
   @value : T
 
   def initialize(value : T)
     {% if T.nilable? %}
-      raise WrapingNil.new("typeof #{{{Some}}} cannot includes Nil")
+      raise WrapingNil.new("typeof #{{{ Some }}} cannot includes Nil")
     {% end %}
 
     @value = value
@@ -308,7 +329,7 @@ end
 struct None(T) < Option(T)
   def initialize
     {% if T.nilable? %}
-      raise WrapingNil.new("typeof #{{{None}}} cannot includes Nil")
+      raise WrapingNil.new("typeof #{{{ None }}} cannot includes Nil")
     {% end %}
   end
 

src/result.cr

@@ -5,6 +5,8 @@ abstract struct Result(T, E)
 
   class UnwrapErrOnOk < Exception; end
 
+  class Uncomparable < Exception; end
+
   macro inherited
     {% type = @type.name(generic_args: false) %}
 
@@ -286,14 +288,35 @@ abstract struct Result(T, E)
   rescue
     Err(T, E).new(error)
   end
+
+  include Comparable(self)
+
+  def <=>(other : Result(T, E)) : Int32
+    case {self, other}
+    when {Ok, Err}
+      -1
+    when {Err, Ok}
+      1
+    else
+      {% if T.has_method?(:<=>) && E.has_method?(:<=>) %}
+        if self.is_a?(Ok)
+          self.unwrap <=> other.unwrap
+        else
+          self.unwrap_err <=> other.unwrap_err
+        end
+      {% else %}
+        0
+      {% end %}
+    end
+  end
 end
 
 struct Ok(T, E) < Result(T, E)
   @value : T
 
   def initialize(value : T)
     {% if T.nilable? || E.nilable? %}
-      raise WrapingNil.new("typeof #{{{Ok}}} cannot includes Nil")
+      raise WrapingNil.new("typeof #{{{ Ok }}} cannot includes Nil")
     {% end %}
 
     @value = value
@@ -309,7 +332,7 @@ struct Err(T, E) < Result(T, E)
 
   def initialize(error : E)
     {% if T.nilable? || E.nilable? %}
-      raise WrapingNil.new("typeof #{{{Err}}} cannot includes Nil")
+      raise WrapingNil.new("typeof #{{{ Err }}} cannot includes Nil")
     {% end %}
 
     @error = error