refactor: new way creating typed value

rename methods
update rubocop config

Author: initdc

.rubocop.yml

@@ -18,3 +18,12 @@ RSpec/ExampleLength:
 
 RSpec/MissingExpectationTargetMethod:
   Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Lint/MissingSuper:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false

lib/rs/option.rb

@@ -5,112 +5,111 @@ module Rs
   # https://doc.rust-lang.org/std/option/index.html
   # https://doc.rust-lang.org/std/option/enum.Option.html
   # https://doc.rust-lang.org/src/core/option.rs.html
-  module Option
-    class ArgumentError < StandardError; end
+  class Option
+    class TypeError < StandardError
+      def initialize(type)
+        super("Expected #{type} to be a Class")
+      end
+    end
+
+    class TypeNilClass < StandardError; end
+    class TypeMismatch < StandardError; end
+    class WrapNil < StandardError; end
     class UnwrapNone < StandardError; end
-    class TypeError < StandardError; end
 
-    def some?
-      @some
+    def is_some
+      is_a?(Some)
     end
 
-    def some_and
-      if !@some
-        false
-      elsif block_given?
-        yield(@value)
-      else
-        @some
-      end
+    def is_some_and(&block)
+      is_some ? block.call(@value) : false
     end
 
-    def none?
-      !@some
+    def is_none
+      is_a?(None)
     end
 
-    def none_or
-      if !@some
-        true
-      elsif block_given?
-        yield(@value)
-      else
-        !@some
-      end
+    def is_none_or(&block)
+      is_none ? true : block.call(@value)
     end
 
     def expect(msg)
-      @some ? @value : raise(UnwrapNone, msg)
+      is_some ? @value : raise(UnwrapNone.new(msg))
     end
 
     def unwrap
-      @some ? @value : raise(UnwrapNone)
+      is_some ? @value : raise(UnwrapNone.new("Called unwrap on None"))
     end
 
-    def unwrap_or(default = nil)
-      if @some
-        @value
-      elsif block_given?
-        yield
-      else
-        default
-      end
+    def unwrap_or(default)
+      is_some ? @value : default
     end
 
     def unwrap_or_else(&block)
-      @some ? @value : block.call
+      is_some ? @value : block.call
     end
   end
 end
 
-class Some
-  include Rs::Option
-
-  attr_reader :type
-  attr_reader :some
-  attr_reader :value
-
-  private :value
-
-  def initialize(value, type: nil)
-    if value == nil
-      raise(Rs::Option::ArgumentError, "Some value cannot be nil")
+class Some < Rs::Option
+  def self.[](type, &block)
+    if !type.is_a?(Class)
+      raise TypeError.new(type)
     end
 
-    if type
-      if value.class != type
-        raise(Rs::Option::TypeError, "Value type #{value.class} does not match #{type}")
-      end
+    if type == NilClass
+      raise TypeNilClass.new("Cannot create Some[T] with NilClass")
+    end
 
-      @type = type
-    else
-      @type = value.class
+    value = block.call
+    if !value.is_a?(type)
+      raise TypeMismatch.new("Expected 'Some[#{type}] { #{value.inspect} }' block.call to be #{type}, not #{value.class}")
     end
 
-    @some = true
-    @value = value
+    new(value)
+  end
+
+  def inspect
+    "Some[#{@value.class}] { #{@value.inspect} }"
   end
 
   def ==(other)
-    other.is_a?(Some) && @type == other.type && @value == other.unwrap
+    other.is_a?(Some) && @value == other.unwrap && @value.class == other.unwrap.class
   end
-end
 
-class None
-  include Rs::Option
+  def initialize(value)
+    if value == nil
+      raise WrapNil.new("Cannot create Some[T](value) with nil")
+    end
+
+    @value = value
+  end
+end
 
+class None < Rs::Option
   attr_reader :type
-  attr_reader :some
-  attr_reader :value
 
-  private :value
+  def self.[](type)
+    new(type)
+  end
 
-  def initialize
-    @type = NilClass
-    @some = false
-    @value = nil
+  def inspect
+    "None[#{@type}]"
   end
 
   def ==(other)
-    other.is_a? None
+    other.is_a?(None) && @type == other.type
+  end
+
+  def initialize(type = Class)
+    if !type.is_a?(Class)
+      raise TypeError.new(type)
+    end
+
+    if type == NilClass
+      raise TypeNilClass.new("Cannot create None[T] with NilClass")
+    end
+
+    @type = type
   end
 end

spec/rs/option_spec.rb

@@ -4,53 +4,71 @@
   # https://doc.rust-lang.org/std/option/enum.Option.html
 
   it "new" do
-    expect { Some.new(nil) }.to raise_error Rs::Option::ArgumentError, "Some value cannot be nil"
+    expect { Some[nil] {} }.to raise_error Rs::Option::TypeError
+    expect { Some[NilClass] { nil } }.to raise_error Rs::Option::TypeNilClass
+    expect { Some[Integer] { nil } }.to raise_error Rs::Option::TypeMismatch
+    expect { Some.new(nil) }.to raise_error Rs::Option::WrapNil
+
+    expect { None[nil] }.to raise_error Rs::Option::TypeError
+    expect { None[NilClass] }.to raise_error Rs::Option::TypeNilClass
+    expect { None.new(nil) }.to raise_error Rs::Option::TypeError
+    expect { None.new(NilClass) }.to raise_error Rs::Option::TypeNilClass
+
+    x = Some.new(2)
+    y = Some[Integer] { 2 }
+    expect(x).to eq y
+
+    x = None.new(Integer)
+    y = None[Integer]
+    expect(x).to eq y
+
+    x = None.new
+    y = None[Class]
+    expect(x).to eq y
   end
 
-  it "some?" do
+  it "is_some" do
     x = Some.new(2)
-    expect(x.some?).to be true
+    expect(x.is_some).to be true
 
     x = None.new
-    expect(x.some?).to be false
+    expect(x.is_some).to be false
   end
 
-  it "some_and proc" do
+  it "is_some_and proc" do
     x = Some.new(2)
-    expect(x.some_and).to be true
-    expect(x.some_and { |x| x > 1 }).to be true
+    expect(x.is_some_and { |x| x > 1 }).to be true
 
     x = Some.new(0)
-    expect(x.some_and { |x| x > 1 }).to be false
+    expect(x.is_some_and { |x| x > 1 }).to be false
 
     x = None.new
-    expect(x.some_and { |x| x.to_i > 1 }).to be false
+    expect(x.is_some_and { |x| x.to_i > 1 }).to be false
 
     x = Some.new("str")
-    expect(x.some_and { |x| x.size > 1 }).to be true
+    expect(x.is_some_and { |x| x.size > 1 }).to be true
   end
 
-  it "none?" do
+  it "is_none" do
     x = Some.new(2)
-    expect(x.none?).to be false
+    expect(x.is_none).to be false
 
     x = None.new
-    expect(x.none?).to be true
+    expect(x.is_none).to be true
   end
 
-  it "none_or proc" do
+  it "is_none_or proc" do
     x = Some.new(2)
-    expect(x.none_or).to be false
-    expect(x.none_or { |x| x > 1 }).to be true
+    expect(x.is_none_or { |x| x > 1 }).to be true
 
     x = Some.new(0)
-    expect(x.none_or { |x| x > 1 }).to be false
+    expect(x.is_none_or { |x| x > 1 }).to be false
 
     x = None.new
-    expect(x.none_or { |x| x.to_i > 1 }).to be true
+    expect(x.is_none_or { |x| x.to_i > 1 }).to be true
 
     x = Some.new("str")
-    expect(x.none_or { |x| x.size > 1 }).to be true
+    expect(x.is_none_or { |x| x.size > 1 }).to be true
   end
 
   it "unwrap" do
@@ -66,12 +84,6 @@
     expect(None.new.unwrap_or("bike")).to eq "bike"
   end
 
-  it "unwrap_or proc" do
-    k = 10
-    expect(Some.new(4).unwrap_or { 2 * k }).to eq 4
-    expect(None.new.unwrap_or { 2 * k }).to eq 20
-  end
-
   it "unwrap_or_else proc" do
     k = 10
     expect(Some.new(4).unwrap_or_else { 2 * k }).to eq 4
@@ -82,8 +94,8 @@
     x = None.new
     y = Some.new(12)
 
-    expect(x.unwrap_or).to be_nil
-    expect(y.unwrap_or).to eq 12
+    expect(x.unwrap_or(0)).to eq 0
+    expect(y.unwrap_or(0)).to eq 12
   end
 
   it "pattern_matching" do
@@ -108,7 +120,7 @@ def divide(numerator, denominator)
   it "type ==" do
     a = Some.new(1)
     b = Some.new(1.0)
-    c = Some.new(1.0, type: Float)
+    c = Some[Float] { 1.0 }
     d = Some.new("a")
     e = None.new