feat: add missing methods, add untyped sig

Add Steepfile
Update rubocop config

Author: initdc

.rubocop.yml

@@ -31,5 +31,11 @@ Naming/PredicatePrefix:
 Metrics/AbcSize:
   Enabled: false
 
+Metrics/ClassLength:
+  Enabled: false
+
 Layout/LineLength:
   Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false

Rakefile

@@ -10,4 +10,4 @@ RuboCop::RakeTask.new do |task|
   task.plugins << "rubocop-rspec"
 end
 
-task default: [:spec, :rubocop]
+task default: [:spec]

Steepfile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  # Directory name
+  check "lib"
+  # ignore "lib/templates/*.rb"
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
+#   signature "sig/test"              # Put RBS files for tests under `sig/test`
+#   check "test"                      # Type check Ruby scripts under `test`
+#
+#   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+#
+#   # library "pathname"              # Standard libraries
+# end

lib/rs/option.rb

@@ -48,6 +48,109 @@ def unwrap_or(default)
     def unwrap_or_else(&block)
       is_some ? @value : block.call
     end
+
+    def map(value_type, &block)
+      if is_some
+        Some[value_type] { block.call(@value) }
+      else
+        None[value_type]
+      end
+    end
+
+    def tap(&block)
+      if is_some
+        value = @value
+        block.call(value)
+      end
+      self
+    end
+
+    def map_or(default, &block)
+      is_some ? block.call(@value) : default
+    end
+
+    def map_or_else(default, &block)
+      is_some ? block.call(@value) : default.call
+    end
+
+    def ok_or(error)
+      if is_some
+        Ok[@value_type, error.class] { @value }
+      else
+        Err[@value_type, error.class] { error }
+      end
+    end
+
+    def ok_or_else(&block)
+      error = block.call
+      if is_some
+        Ok[@value_type, error.class] { @value }
+      else
+        Err[@value_type, error.class] { error }
+      end
+    end
+
+    def and(other)
+      is_some ? other : None[other.value_type]
+    end
+
+    def and_then(value_type, &block)
+      is_some ? block.call(@value) : None[value_type]
+    end
+
+    def select(&block)
+      if is_some
+        value = @value
+        block.call(value) ? self : None[@value_type]
+      else
+        None[@value_type]
+      end
+    end
+
+    def or(other)
+      if is_some
+        self
+      else
+        other
+      end
+    end
+
+    def or_else(&block)
+      is_some ? self : block.call
+    end
+
+    def xor(other)
+      case [is_some, other.is_some]
+      when [true, false]
+        self
+      when [false, true]
+        other
+      when [true, true]
+        None[@value_type]
+      else
+        None[@value_type]
+      end
+    end
+
+    def self.from(value_type, &block)
+      Some[value_type, &block]
+    end
+
+    def self.from?(value_type, &block)
+      value = block.call
+      if value == nil
+        None[value_type]
+      else
+        Some[value_type] { value }
+      end
+    end
+
+    def self.from!(value_type, &block)
+      value = block.call
+      Some[value_type] { value }
+    rescue StandardError
+      None[value_type]
+    end
   end
 end
 

lib/rs/result.rb

@@ -36,11 +36,59 @@ def is_err_and(&block)
     end
 
     def ok
-      is_ok ? Some[@value_type] { @value } : None[@value_type]
+      if is_ok
+        Some[@value_type] { @value }
+      else
+        None[@value_type]
+      end
     end
 
     def err
-      is_err ? Some[@error_type] { @error } : None[@error_type]
+      if is_err
+        Some[@error_type] { @error }
+      else
+        None[@error_type]
+      end
+    end
+
+    def map(value_type, &block)
+      if is_ok
+        Ok[value_type, @error_type] { block.call(@value) }
+      else
+        Err[value_type, @error_type] { @error }
+      end
+    end
+
+    def map_or(default, &block)
+      is_ok ? block.call(@value) : default
+    end
+
+    def map_or_else(default, &block)
+      is_ok ? block.call(@value) : default.call(@error)
+    end
+
+    def map_err(error_type, &block)
+      if is_ok
+        Ok[@value_type, error_type] { @value }
+      else
+        Err[@value_type, error_type] { block.call(@error) }
+      end
+    end
+
+    def tap(&block)
+      if is_ok
+        value = @value
+        block.call(value)
+      end
+      self
+    end
+
+    def tap_err(&block)
+      if is_err
+        error = @error
+        block.call(error)
+      end
+      self
     end
 
     def expect(msg)
@@ -51,6 +99,46 @@ def unwrap
       is_ok ? @value : raise(UnwrapOnErr.new("called unwrap on an Err value: #{@error}"))
     end
 
+    def expect_err(msg)
+      is_ok ? raise(UnwrapErrOnOk.new("#{msg}: #{@value}")) : @error
+    end
+
+    def unwrap_err
+      is_ok ? raise(UnwrapErrOnOk.new("called unwrap_err() on an Ok value: #{@value}")) : @error
+    end
+
+    def and(other)
+      if is_ok
+        other
+      else
+        Err[other.value_type, @error_type] { @error }
+      end
+    end
+
+    def and_then(value_type, &block)
+      if is_ok
+        block.call(@value)
+      else
+        Err[value_type, @error_type] { @error }
+      end
+    end
+
+    def or(other)
+      if is_ok
+        Ok[@value_type, other.error_type] { @value }
+      else
+        other
+      end
+    end
+
+    def or_else(error_type, &block)
+      if is_ok
+        Ok[@value_type, error_type] { @value }
+      else
+        block.call(@error)
+      end
+    end
+
     def unwrap_or(default)
       is_ok ? @value : default
     end
@@ -59,12 +147,24 @@ def unwrap_or_else(&block)
       is_ok ? @value : block.call(@error)
     end
 
-    def expect_err(msg)
-      is_ok ? raise(UnwrapErrOnOk.new("#{msg}: #{@value}")) : @error
+    def self.from_or(value_type, error, &block)
+      Ok[value_type, error.class] { block.call }
     end
 
-    def unwrap_err
-      is_ok ? raise(UnwrapErrOnOk.new("called unwrap_err() on an Ok value: #{@value}")) : @error
+    def self.from_or?(value_type, error, &block)
+      value = block.call
+      if value == nil
+        Err[value_type, error.class] { error }
+      else
+        Ok[value_type, error.class] { value }
+      end
+    end
+
+    def self.from_or!(value_type, error, &block)
+      value = block.call
+      Ok[value_type, error.class] { value }
+    rescue StandardError
+      Err[value_type, error.class] { error }
     end
   end
 end

sig/rs/option.rbs

@@ -0,0 +1,98 @@
+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
+  class Option
+    class TypeError < StandardError
+      def initialize: (untyped value_type) -> void
+    end
+
+    class TypeNilClass < StandardError
+    end
+
+    class TypeMismatch < StandardError
+    end
+
+    class WrapNil < StandardError
+    end
+
+    class UnwrapNone < StandardError
+    end
+
+    def is_some: () -> untyped
+
+    def is_some_and: () { (?) -> untyped } -> (untyped | false)
+
+    def is_none: () -> untyped
+
+    def is_none_or: () { (?) -> untyped } -> (true | untyped)
+
+    def expect: (untyped msg) -> untyped
+
+    def unwrap: () -> untyped
+
+    def unwrap_or: (untyped default) -> untyped
+
+    def unwrap_or_else: () { (?) -> untyped } -> untyped
+
+    def map: (untyped value_type) { (?) -> untyped } -> untyped
+
+    def map_or: (untyped default) { (?) -> untyped } -> untyped
+
+    def map_or_else: (untyped default) { (?) -> untyped } -> untyped
+
+    def ok_or: (untyped error) -> untyped
+
+    def ok_or_else: () { (?) -> untyped } -> untyped
+
+    def and: (untyped other) -> untyped
+
+    def and_then: (untyped value_type) { (?) -> untyped } -> untyped
+
+    def select: () { (?) -> untyped } -> (self | untyped | untyped)
+
+    def or: (untyped other) -> (self | untyped)
+
+    def or_else: () { (?) -> untyped } -> (self | untyped)
+
+    def xor: (untyped other) -> untyped
+
+    def tap: () { (?) -> untyped } -> self
+
+    def self.from: (untyped value_type) { (?) -> untyped } -> untyped
+
+    def self.from?: (untyped value_type) { (?) -> untyped } -> untyped
+
+    def self.from!: (untyped value_type) { (?) -> untyped } -> untyped
+  end
+end
+
+class Some < Rs::Option
+  @value: untyped
+
+  @value_type: untyped
+
+  attr_reader value_type: untyped
+
+  def self.[]: (untyped value_type) { (?) -> untyped } -> untyped
+
+  def inspect: () -> ::String
+
+  def ==: (untyped other) -> untyped
+
+  def initialize: (untyped value) -> void
+end
+
+class None < Rs::Option
+  @value_type: untyped
+
+  attr_reader value_type: untyped
+
+  def self.[]: (untyped value_type) -> untyped
+
+  def inspect: () -> ::String
+
+  def ==: (untyped other) -> untyped
+
+  def initialize: (?untyped value_type) -> void
+end