perf: add missing types, cause they gona be accessing many times

Author: initdc

lib/rs/option.rb

@@ -7,8 +7,8 @@ module Rs
   # https://doc.rust-lang.org/src/core/option.rs.html
   class Option
     class TypeError < StandardError
-      def initialize(type)
-        super("Expected #{type} to be a Class")
+      def initialize(value_type)
+        super("Expected #{value_type} to be a Class")
       end
     end
 
@@ -52,29 +52,31 @@ def unwrap_or_else(&block)
 end
 
 class Some < Rs::Option
-  def self.[](type, &block)
-    if !type.is_a?(Class)
-      raise TypeError.new(type)
+  attr_reader :value_type
+
+  def self.[](value_type, &block)
+    if !value_type.is_a?(Class)
+      raise TypeError.new(value_type)
     end
 
-    if type == NilClass
+    if value_type == NilClass
       raise TypeNilClass.new("Cannot create Some[T] with NilClass")
     end
 
     value = block.call
-    if !value.is_a?(type)
-      raise TypeMismatch.new("Expected 'Some[#{type}] { #{value.inspect} }' block.call to be #{type}, not #{value.class}")
+    if !value.is_a?(value_type)
+      raise TypeMismatch.new("Expected 'Some[#{value_type}] { #{value.inspect} }' block.call to be #{value_type}, not #{value.class}")
     end
 
     new(value)
   end
 
   def inspect
-    "Some[#{@value.class}] { #{@value.inspect} }"
+    "Some[#{@value_type}] { #{@value.inspect} }"
   end
 
   def ==(other)
-    other.is_a?(Some) && @value == other.unwrap && @value.class == other.unwrap.class
+    other.is_a?(Some) && @value == other.unwrap && @value_type == other.value_type
   end
 
   def initialize(value)
@@ -83,33 +85,34 @@ def initialize(value)
     end
 
     @value = value
+    @value_type = value.class
   end
 end
 
 class None < Rs::Option
-  attr_reader :type
+  attr_reader :value_type
 
-  def self.[](type)
-    new(type)
+  def self.[](value_type)
+    new(value_type)
   end
 
   def inspect
-    "None[#{@type}]"
+    "None[#{@value_type}]"
   end
 
   def ==(other)
-    other.is_a?(None) && @type == other.type
+    other.is_a?(None) && @value_type == other.value_type
   end
 
-  def initialize(type = Class)
-    if !type.is_a?(Class)
-      raise TypeError.new(type)
+  def initialize(value_type = Class)
+    if !value_type.is_a?(Class)
+      raise TypeError.new(value_type)
     end
 
-    if type == NilClass
+    if value_type == NilClass
       raise TypeNilClass.new("Cannot create None[T] with NilClass")
     end
 
-    @type = type
+    @value_type = value_type
   end
 end

lib/rs/result.rb

@@ -36,11 +36,11 @@ def is_err_and(&block)
     end
 
     def ok
-      is_ok ? Some[@value.class] { @value } : None[@value_type]
+      is_ok ? Some[@value_type] { @value } : None[@value_type]
     end
 
     def err
-      is_err ? Some[@error.class] { @error } : None[@error_type]
+      is_err ? Some[@error_type] { @error } : None[@error_type]
     end
 
     def expect(msg)
@@ -70,6 +70,7 @@ def unwrap_err
 end
 
 class Ok < Rs::Result
+  attr_accessor :value_type
   attr_accessor :error_type
 
   def self.[](value_type, error_type, &block)
@@ -96,11 +97,11 @@ def self.[](value_type, error_type, &block)
   end
 
   def inspect
-    "Ok[#{@value.class}, #{@error_type}] { #{@value.inspect} }"
+    "Ok[#{@value_type}, #{@error_type}] { #{@value.inspect} }"
   end
 
   def ==(other)
-    other.is_a?(Ok) && @value == other.unwrap && @value.class == other.unwrap.class && @error_type == other.error_type
+    other.is_a?(Ok) && @value == other.unwrap && @value_type == other.value_type && @error_type == other.error_type
   end
 
   def initialize(value)
@@ -109,12 +110,14 @@ def initialize(value)
     end
 
     @value = value
+    @value_type = value.class
     @error_type = Class
   end
 end
 
 class Err < Rs::Result
   attr_accessor :value_type
+  attr_accessor :error_type
 
   def self.[](value_type, error_type, &block)
     if !value_type.is_a?(Class) || !error_type.is_a?(Class)
@@ -140,11 +143,11 @@ def self.[](value_type, error_type, &block)
   end
 
   def inspect
-    "Err[#{@value_type}, #{@error.class}] { #{@error.inspect} }"
+    "Err[#{@value_type}, #{@error_type}] { #{@error.inspect} }"
   end
 
   def ==(other)
-    other.is_a?(Err) && @error == other.unwrap_err && @error.class == other.unwrap_err.class && @value_type == other.value_type
+    other.is_a?(Err) && @error == other.unwrap_err && @value_type == other.value_type && @error_type == other.error_type
   end
 
   def initialize(error)
@@ -153,6 +156,7 @@ def initialize(error)
     end
 
     @error = error
+    @error_type = error.class
     @value_type = Class
   end
 end