refactor: new way creating typed Result

Author: initdc

.rubocop.yml

@@ -26,4 +26,7 @@ Lint/MissingSuper:
   Enabled: false
 
 Naming/PredicatePrefix:
+  Enabled: false
+
+Metrics/AbcSize:
   Enabled: false

lib/rs/result.rb

@@ -1,152 +1,158 @@
 # frozen_string_literal: true
 
-require_relative "option"
 require_relative "result/version"
 
 module Rs
   # https://doc.rust-lang.org/std/result/index.html
   # https://doc.rust-lang.org/std/result/enum.Result.html
   # https://doc.rust-lang.org/src/core/result.rs.html
-  module Result
-    class ArgumentError < StandardError; end
+  class Result
+    class TypeError < StandardError
+      def initialize(value_type, error_type)
+        super("Expected #{value_type} or #{error_type} to be a Class")
+      end
+    end
+
+    class TypeNilClass < StandardError; end
+    class TypeMismatch < StandardError; end
+    class WrapNil < StandardError; end
     class UnwrapOnErr < StandardError; end
     class UnwrapErrOnOk < StandardError; end
-    class TypeError < StandardError; end
 
-    def ok?
-      @ok
+    def is_ok
+      is_a?(Ok)
     end
 
-    def ok_and
-      if !@ok
-        false
-      elsif block_given?
-        yield(@value)
-      else
-        @ok
-      end
+    def is_ok_and(&block)
+      is_ok ? block.call(@value) : false
     end
 
-    def err?
-      !@ok
+    def is_err
+      is_a?(Err)
     end
 
-    def err_and
-      if @ok
-        false
-      elsif block_given?
-        yield(@value)
-      else
-        !@ok
-      end
+    def is_err_and(&block)
+      is_err ? block.call(@error) : false
     end
 
     def ok
-      if @ok
-        Some.new(@value)
-      else
-        None.new
-      end
+      is_ok ? Some[@value.class] { @value } : None[@value_type]
     end
 
     def err
-      if !@ok
-        Some.new(@value)
-      else
-        None.new
-      end
+      is_err ? Some[@error.class] { @error } : None[@error_type]
     end
 
     def expect(msg)
-      @ok ? @value : raise(UnwrapOnErr, "#{msg}: #{@value}")
+      is_ok ? @value : raise(UnwrapOnErr.new("#{msg}: #{@error}"))
     end
 
     def unwrap
-      @ok ? @value : raise(UnwrapOnErr, "called `Result::unwrap()` on an `Err` value: #{@value}")
+      is_ok ? @value : raise(UnwrapOnErr.new("called unwrap on an Err value: #{@error}"))
     end
 
-    def unwrap_or(default = nil)
-      if @ok
-        @value
-      elsif block_given?
-        yield
-      else
-        default
-      end
+    def unwrap_or(default)
+      is_ok ? @value : default
     end
 
     def unwrap_or_else(&block)
-      @ok ? @value : block.call(@value)
+      is_ok ? @value : block.call(@error)
     end
 
     def expect_err(msg)
-      @ok ? raise(UnwrapErrOnOk, "#{msg}: #{@value}") : @value
+      is_ok ? raise(UnwrapErrOnOk.new("#{msg}: #{@value}")) : @error
     end
 
     def unwrap_err
-      @ok ? raise(UnwrapErrOnOk, "called `Result::unwrap_err()` on an `Ok` value: #{@value}") : @value
+      is_ok ? raise(UnwrapErrOnOk.new("called unwrap_err() on an Ok value: #{@value}")) : @error
     end
   end
 end
 
-class Ok
-  include Rs::Result
-
-  attr_reader :type
-  attr_reader :ok
-  attr_reader :value
+class Ok < Rs::Result
+  attr_accessor :error_type
 
-  private :value
+  def self.[](value_type, error_type, &block)
+    if !value_type.is_a?(Class) || !error_type.is_a?(Class)
+      raise TypeError.new(value_type, error_type)
+    end
 
-  def initialize(value, type: nil)
-    if value == nil
-      raise(Rs::Result::ArgumentError, "Ok value cannot be nil")
+    if value_type == NilClass || error_type == NilClass
+      raise TypeNilClass.new("Cannot create Ok[T, E] with [#{value_type}, #{error_type}]")
     end
 
-    if type
-      if value.class != type
-        raise(Rs::Result::TypeError, "Value type #{value.class} does not match #{type}")
-      end
+    value = block.call
+    if !value.is_a?(value_type)
+      raise TypeMismatch.new("Expected 'Ok[#{value_type}, #{error_type}] { #{value.inspect} }' block.call to be #{value_type}, not #{value.class}")
+    end
 
-      @type = type
-    else
-      @type = value.class
+    if value == nil
+      raise WrapNil.new("Cannot create Ok[#{value_type}, #{error_type}] with nil")
     end
 
-    @ok = true
-    @value = value
+    ok_instance = Ok.new(value)
+    ok_instance.error_type = error_type
+    ok_instance
+  end
+
+  def inspect
+    "Ok[#{@value.class}, #{@error_type}] { #{@value.inspect} }"
   end
 
   def ==(other)
-    other.is_a?(Ok) && @type == other.type && @value == other.unwrap
+    other.is_a?(Ok) && @value == other.unwrap && @value.class == other.unwrap.class && @error_type == other.error_type
+  end
+
+  def initialize(value)
+    if value == nil
+      raise WrapNil.new("Cannot create Ok[T, E] with nil")
+    end
+
+    @value = value
+    @error_type = Class
   end
 end
 
-class Err
-  include Rs::Result
+class Err < Rs::Result
+  attr_accessor :value_type
 
-  attr_reader :type
-  attr_reader :ok
-  attr_reader :value
+  def self.[](value_type, error_type, &block)
+    if !value_type.is_a?(Class) || !error_type.is_a?(Class)
+      raise TypeError.new(value_type, error_type)
+    end
 
-  private :value
+    if value_type == NilClass || error_type == NilClass
+      raise TypeNilClass.new("Cannot create Err[T, E] with [#{value_type}, #{error_type}]")
+    end
 
-  def initialize(error, type: nil)
-    if type
-      if error.class != type
-        raise(Rs::Result::TypeError, "Error type #{error.class} does not match #{type}")
-      end
+    error = block.call
+    if !error.is_a?(error_type)
+      raise TypeMismatch.new("Expected 'Err[#{value_type}, #{error_type}] { #{error.inspect} }' block.call to be #{error_type}, not #{error.class}")
+    end
 
-      @type = type
-    else
-      @type = error.class
+    if error == nil
+      raise WrapNil.new("Cannot create Err[#{value_type}, #{error_type}] with nil")
     end
 
-    @ok = false
-    @value = error
+    error_instance = Err.new(error)
+    error_instance.value_type = value_type
+    error_instance
+  end
+
+  def inspect
+    "Err[#{@value_type}, #{@error.class}] { #{@error.inspect} }"
   end
 
   def ==(other)
-    other.is_a?(Err) && @type == other.type && @value == other.unwrap_err
+    other.is_a?(Err) && @error == other.unwrap_err && @error.class == other.unwrap_err.class && @value_type == other.value_type
+  end
+
+  def initialize(error)
+    if error == nil
+      raise WrapNil.new("Cannot create Err[T, E] with nil")
+    end
+
+    @error = error
+    @value_type = Class
   end
 end

lib/rs/result/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Rs
-  module Result
+  class Result
     VERSION = "0.1.1"
   end
 end