chore: add types file, update sig for Option

Author: initdc

README.md

@@ -15,7 +15,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 ## Usage
 
 ```ruby
-require "rs/result"
+require "rs/types"
 
 x = Some.new(2)
 x = None.new

Steepfile

@@ -6,10 +6,10 @@ target :lib do
   signature "sig"
 
   # Directory name
-  check "lib"
+  check "lib/rs/types"
   # ignore "lib/templates/*.rb"
 
-  # library "pathname"              # Standard libraries
+  # library "rs/types"              # Standard libraries
   # library "strong_json"           # Gems
 
   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)

lib/rs/option.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "result/version"
+
 module Rs
   # https://doc.rust-lang.org/std/option/index.html
   # https://doc.rust-lang.org/std/option/enum.Option.html

lib/rs/types.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "option"
+require_relative "result"

lib/rs/types/T.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class T
+  def initialize(value)
+    @value = value
+  end
+
+  def inspect
+    "T[#{@value.class}]"
+  end
+end
+
+class TE
+  def initialize(value, error)
+    @value = value
+    @error = error
+  end
+
+  def inspect
+    "TE[#{@value.class}, #{@error.class}]"
+  end
+end
+
+# p T.new(0)
+# p TE.new(0, "a")
+
+# p = Proc.new { |x| p x }
+# l = lambda { |x| p x }
+# a1 = -> (x) { p x }
+
+# a1.(6, 0)

sig/rs/option.rbs

@@ -2,9 +2,11 @@ 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 Option[V]
     class TypeError < StandardError
-      def initialize: (untyped value_type) -> void
+      # wanted Class[V]
+      # no need declare new type V
+      def initialize: [V] (T[V] value_type) -> void
     end
 
     class TypeNilClass < StandardError
@@ -19,80 +21,93 @@ module Rs
     class UnwrapNone < StandardError
     end
 
-    def is_some: () -> untyped
+    def is_some: () -> bool
 
-    def is_some_and: () { (?) -> untyped } -> (untyped | false)
+    def is_some_and: () { (V) -> bool } -> bool
 
-    def is_none: () -> untyped
+    def is_none: () -> bool
 
-    def is_none_or: () { (?) -> untyped } -> (true | untyped)
+    def is_none_or: () { (V) -> bool } -> bool
 
-    def expect: (untyped msg) -> untyped
+    def expect: (String msg) -> V
 
-    def unwrap: () -> untyped
+    def unwrap: () -> V
 
-    def unwrap_or: (untyped default) -> untyped
+    def unwrap_or: (V default) -> V
 
-    def unwrap_or_else: () { (?) -> untyped } -> untyped
+    def unwrap_or_else: () { () -> V } -> V
 
-    def map: (untyped value_type) { (?) -> untyped } -> untyped
+    def map: [U] (T[U] value_type) { (V) -> U } -> Option[U]
 
-    def tap: () { (?) -> untyped } -> self
+    def tap: () { (V) -> bool } -> self
 
-    def map_or: (untyped default) { (?) -> untyped } -> untyped
+    def map_or: [U] (U default) { (V) -> U } -> U
 
-    def map_or_else: (untyped default) { (?) -> untyped } -> untyped
+    # work
+    # type int_or_string = Integer | String
+    # 
+    # not work
+    # type ld = lambda { () -> U }
+    # type ld = lambda { -> U }
+    # type pd = Proc(U)
+    # 
+    # want, crystal like
+    # type D = -> U
+    # type F = (V) -> U
+    # type F = V -> U
+    def map_or_else: [U] (Proc default) { (V) -> U } -> U
 
-    def ok_or: (untyped error) -> untyped
+    def ok_or: [E] (E error) -> Rs::Result[V, E]
 
-    def ok_or_else: () { (?) -> untyped } -> untyped
+    def ok_or_else: [E] () { () -> E } -> Rs::Result[V, E]
 
-    def and: (untyped other) -> untyped
+    def and: [U] (Option[U] other) -> Option[U]
 
-    def and_then: (untyped value_type) { (?) -> untyped } -> untyped
+    def and_then: [U] (T[U] value_type) { (V) -> Option[U] } -> Option[U]
 
-    def select: () { (?) -> untyped } -> untyped
+    def select: () { (V) -> bool } -> bool
 
-    def or: (untyped other) -> (self | untyped)
+    def or: (self other) -> self
 
-    def or_else: () { (?) -> untyped } -> (self | untyped)
+    def or_else: () { () -> self } -> self
 
-    def xor: (untyped other) -> untyped
+    def xor: (self other) -> self
 
-    def self.from: (untyped value_type) { (?) -> untyped } -> untyped
+    def self.from: [V] (T[V] value_type) { () -> V } -> self
 
-    def self.from?: (untyped value_type) { (?) -> untyped } -> untyped
+    def self.from?: [V] (T[V] value_type) { () -> V? } -> self
 
-    def self.from!: (untyped value_type) { (?) -> untyped } -> untyped
+    def self.from!: [V] (T[V] value_type) { () -> V } -> self
   end
 end
 
-class Some < Rs::Option
-  @value: untyped
+class Some[V] < Rs::Option[V]
+  @value: V
 
-  @value_type: untyped
+  # wanted Class[V]
+  @value_type: T[V]
 
-  attr_reader value_type: untyped
+  attr_reader value_type: T[V]
 
-  def self.[]: (untyped value_type) { (?) -> untyped } -> untyped
+  def self.[]: [V] (T[V] value_type) { () -> V } -> self
 
   def inspect: () -> ::String
 
-  def ==: (untyped other) -> untyped
+  def ==: (Rs::Option[V] other) -> bool
 
-  def initialize: (untyped value) -> void
+  def initialize: (V value) -> void
 end
 
-class None < Rs::Option
-  @value_type: untyped
+class None[V] < Rs::Option[V]
+  @value_type: T[V]
 
-  attr_reader value_type: untyped
+  attr_reader value_type: T[V]
 
-  def self.[]: (untyped value_type) -> untyped
+  def self.[]: [V] (T[V] value_type) -> self
 
   def inspect: () -> ::String
 
-  def ==: (untyped other) -> untyped
+  def ==: (Rs::Option[V] other) -> bool
 
-  def initialize: (?untyped value_type) -> void
+  def initialize: (?T[V] value_type) -> void
 end

sig/rs/result.rbs

@@ -2,7 +2,9 @@ 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
-  class Result
+  class Result[V, E]
+    VERSION: String
+
     class TypeError < StandardError
       def initialize: (untyped value_type, untyped error_type) -> void
     end
@@ -74,7 +76,7 @@ module Rs
   end
 end
 
-class Ok < Rs::Result
+class Ok[V, E] < Rs::Result[V, E]
   @value: untyped
 
   @value_type: untyped
@@ -94,7 +96,7 @@ class Ok < Rs::Result
   def initialize: (untyped value) -> void
 end
 
-class Err < Rs::Result
+class Err[V, E] < Rs::Result[V, E]
   @error: untyped
 
   @error_type: untyped

sig/rs/types/T.rbs

@@ -0,0 +1,18 @@
+class T[T]
+  @value: T
+
+  def initialize: (T value) -> void
+  
+  # every thing is object
+  # why raise error Type `E` does not have method `class`
+  def inspect: () -> ::String
+end
+
+class TE[T, E]
+  @value: T
+
+  @error: E
+
+  def initialize: (T value, E error) -> void
+  def inspect: () -> ::String
+end

spec/spec_helper.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require "rs/option"
-require "rs/result"
+require "rs/types"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure