mangrove 0.24.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa2f22dcbb9d2f0da9e28c414cb0c5031ca0e85efae1fb1ff43f9f7fedb27467
-  data.tar.gz: ee48cde475b14fd8d1f558b77b9208c597d39ed6e94280008c08b722bc870ad2
+  metadata.gz: 40399ea0d669ab22b7a7e87339f2805639fff8f3637d92cbd2053e808c2cfd51
+  data.tar.gz: 001bb14fdf77d56956f9a58bd516639c33db9dc5c7e49a866504d617a7f58541
 SHA512:
-  metadata.gz: bc8872e6bc079a3ff532212477cced1f87f09fc0f600c0a6a2abad0ce4ba46689dcafda6f9ec7519f33b76c45cdc0bfde527c60f85a25cbea069d3c68e64d981
-  data.tar.gz: 22092ce2f3907e1419efb6686e5fd588ed39d37d40f6fa1a0a5b446655fd2e90e6466cace05ec7e993b3d2d57bc1a994698d531c2fe7102cfc6f016f5164134f
+  metadata.gz: 8d2a3fc17f9add3fa5b58f7069782fcde4bf09c1237d3e8897e68f6809f1ed0e1548679475560e13c780d4c6f1eadede337c4e0fb9a552c32c4c6753d0fc38cc
+  data.tar.gz: 2e0b2daa053cb9e1116597f21f9eeebac38ae1b174313cca1f612a992983f4fe8d92e7243751664d3f3f8f1ed7b5a1d91843282ea503ff5dae85909ad0d8b471

data/README.md

@@ -1,14 +1,12 @@
 # Mangrove
-Mangrove provides type utility to use with Sorbet.
 
 Mangrove is a Ruby Gem designed to be the definitive toolkit for leveraging Sorbet's type system in Ruby applications. It's designed to offer a robust, statically-typed experience, focusing on solid types, a functional programming style, and an interface-driven approach.
 
-Use `rubocop-mangrove` to statically check rescuing ControlSignal is done
-
 - [Documentation](https://kazzix14.github.io/mangrove/docs/)
 - [Coverage](https://kazzix14.github.io/mangrove/coverage/index.html#_AllFiles)
 
 ## Features
+
 - Option Type
 - Result Type
 - Enums with inner types (ADTs)
@@ -36,9 +34,38 @@ my_ok = Result::Ok.new("my value")
 my_err = Result::Err.new("my err")
 my_some = Option::Some.new(1234)
 my_none = Option::None.new
+
+##############################
+
+response = MyClient
+  .new
+  .and_then { |client| client.get_response() }
+  .and_then { |response| response.body }
+
+case response
+when Mangrove::Result::Ok
+  puts response.ok_inner
+when Mangrove::Result::Err
+  puts response.err_inner
+end
+
+##############################
+
+class MyEnum
+  extend Mangrove::Enum
+
+  variants do
+    variant VariantWithInteger, Integer
+    variant VariantWithString, String
+    variant VariantWithException, Exception
+    variant VariantWithTuple, [Integer, String]
+    variant VariantWithShape, { name: String, age: Integer }
+  end
+end
 ```
 
 ## Commands for Development
+
 ```
 git config core.hooksPath hooks
 bundle install
@@ -50,9 +77,9 @@ bundle exec tapioca init
 bundle exec rspec -f d
 bundle exec rubocop -DESP
 bundle exec srb typecheck
-bundle exec spoom tc
+bundle exec spoom srb tc
 bundle exec ordinare --check
-bundle exec ruboclean
+bundle exec ruboclean --verify
 bundle exec yardoc -o docs/ --plugin yard-sorbet
 bundle exec yard server --reload --plugin yard-sorbet
 rake build

data/lib/mangrove/result.rb

@@ -15,8 +15,8 @@ module Mangrove
     sealed!
     interface!
 
-    OkType = type_member
-    ErrType = type_member
+    OkType = type_member(:out)
+    ErrType = type_member(:out)
 
     sig { abstract.params(other: BasicObject).returns(T::Boolean) }
     def ==(other); end
@@ -51,7 +51,7 @@ module Mangrove
     sig { abstract.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
     def map(&block); end
 
-    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T.type_parameter(:NewOkType), _t_new_err: T.type_parameter(:NewErrType), block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
     def map_wt(_t_new_ok, _t_new_err, &block); end
 
     sig { abstract.type_parameters(:NewOkType).params(block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
@@ -66,44 +66,46 @@ module Mangrove
     sig { abstract.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
     def map_err_wt(_t_new_err, &block); end
 
-    sig { abstract.type_parameters(:NewOkType).params(other: Result[T.type_parameter(:NewOkType), ErrType]).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(T.any(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType])) }
     def and(other); end
 
-    sig { abstract.type_parameters(:NewOkType).params(block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType])) }
     def and_then(&block); end
 
-    sig { abstract.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), ErrType])) }
     def and_then_wt(_t_new_ok, &block); end
 
     sig {
       abstract
+        .type_parameters(:NewErrType)
         .params(
-          new_err_inner: ErrType,
+          new_err_inner: T.type_parameter(:NewErrType),
           condition: T.proc.params(inner: OkType).returns(T::Boolean)
         )
         .returns(
-          Result[OkType, ErrType]
+          T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[OkType, ErrType])
         )
     }
     def and_err_if(new_err_inner, &condition); end
 
-    sig { abstract.params(other: Result[OkType, ErrType]).returns(Result[OkType, ErrType]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])) }
     def or(other); end
 
-    sig { abstract.type_parameters(:NewErrType).params(block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])) }
     def or_else(&block); end
 
-    sig { abstract.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
+    sig { abstract.type_parameters(:NewOkType, :NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(T.any(Result[OkType, T.type_parameter(:NewErrType)], Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])) }
     def or_else_wt(_t_new_err, &block); end
 
     sig {
       abstract
+        .type_parameters(:NewOkType)
         .params(
-          new_ok_inner: OkType,
+          new_ok_inner: T.type_parameter(:NewOkType),
           condition: T.proc.params(inner: ErrType).returns(T::Boolean)
         )
         .returns(
-          Result[OkType, ErrType]
+          T.any(Result[T.type_parameter(:NewOkType), ErrType], Result[OkType, ErrType])
         )
     }
     def or_ok_if(new_ok_inner, &condition); end
@@ -121,31 +123,33 @@ module Mangrove
 
         if errs.empty?
           # This is safe as errs is empty.
-          Result::Ok[T::Enumerable[T.type_parameter(:T)], T::Enumerable[T.type_parameter(:E)]].new(results.map { |r| T.cast(r, Result::Ok[T.type_parameter(:T), T.type_parameter(:E)]).ok_inner })
+          Result::Ok[T::Enumerable[T.type_parameter(:T)]].new(results.map { |r| T.cast(r, Result::Ok[T.type_parameter(:T)]).ok_inner })
         else
           # This is safe as errs is results where err? is true
-          Result::Err[T::Enumerable[T.type_parameter(:T)], T::Enumerable[T.type_parameter(:E)]].new(errs.map { |r| T.cast(r, Result::Err[T.type_parameter(:T), T.type_parameter(:E)]).err_inner })
+          Result::Err[T::Enumerable[T.type_parameter(:E)]].new(errs.map { |r| T.cast(r, Result::Err[T.type_parameter(:E)]).err_inner })
         end
       end
 
-      sig { type_parameters(:OkType).params(inner: T.type_parameter(:OkType)).returns(Result::Ok[T.type_parameter(:OkType), T.untyped]) }
+      sig { type_parameters(:OkType).params(inner: T.type_parameter(:OkType)).returns(Result::Ok[T.type_parameter(:OkType)]) }
       def ok(inner)
-        Result::Ok[T.type_parameter(:OkType), T.untyped].new(inner)
+        Result::Ok[T.type_parameter(:OkType)].new(inner)
       end
 
-      sig { type_parameters(:OkType, :ErrType).params(inner: T.type_parameter(:OkType), _t_err: T::Class[T.type_parameter(:ErrType)]).returns(Result::Ok[T.type_parameter(:OkType), T.type_parameter(:ErrType)]) }
+      # @deprecated
+      sig { type_parameters(:OkType, :ErrType).params(inner: T.type_parameter(:OkType), _t_err: T::Class[T.type_parameter(:ErrType)]).returns(Result::Ok[T.type_parameter(:OkType)]) }
       def ok_wt(inner, _t_err)
-        Result::Ok[T.type_parameter(:OkType), T.type_parameter(:ErrType)].new(inner)
+        Result::Ok[T.type_parameter(:OkType)].new(inner)
       end
 
-      sig { type_parameters(:ErrType).params(inner: T.type_parameter(:ErrType)).returns(Result::Err[T.untyped, T.type_parameter(:ErrType)]) }
+      sig { type_parameters(:ErrType).params(inner: T.type_parameter(:ErrType)).returns(Result::Err[T.type_parameter(:ErrType)]) }
       def err(inner)
-        Result::Err[T.untyped, T.type_parameter(:ErrType)].new(inner)
+        Result::Err[T.type_parameter(:ErrType)].new(inner)
       end
 
-      sig { type_parameters(:OkType, :ErrType).params(_t_ok: T::Class[T.type_parameter(:OkType)], inner: T.type_parameter(:ErrType)).returns(Result::Err[T.type_parameter(:OkType), T.type_parameter(:ErrType)]) }
+      # @deprecated
+      sig { type_parameters(:OkType, :ErrType).params(_t_ok: T::Class[T.type_parameter(:OkType)], inner: T.type_parameter(:ErrType)).returns(Result::Err[T.type_parameter(:ErrType)]) }
       def err_wt(_t_ok, inner)
-        Result::Err[T.type_parameter(:OkType), T.type_parameter(:ErrType)].new(inner)
+        Result::Err[T.type_parameter(:ErrType)].new(inner)
       end
     end
 
@@ -157,7 +161,7 @@ module Mangrove
       include Result
 
       OkType = type_member
-      ErrType = type_member
+      ErrType = type_member { { fixed: T.noreturn } }
 
       sig { params(inner: OkType).void }
       def initialize(inner)
@@ -225,89 +229,93 @@ module Mangrove
         block.call(self)
       end
 
-      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T.type_parameter(:NewOkType), _t_new_err: T.type_parameter(:NewErrType), block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def map_wt(_t_new_ok, _t_new_err, &block)
         block.call(self)
       end
 
       sig { override.type_parameters(:NewOkType).params(block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def map_ok(&block)
-        Result::Ok[T.type_parameter(:NewOkType), ErrType].new(block.call(@inner))
+        Result::Ok[T.type_parameter(:NewOkType)].new(block.call(@inner))
       end
 
       # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def map_ok_wt(_t_new_ok, &block)
-        Result::Ok[T.type_parameter(:NewOkType), ErrType].new(block.call(@inner))
+        Result::Ok[T.type_parameter(:NewOkType)].new(block.call(@inner))
       end
 
       sig { override.type_parameters(:NewErrType).params(_block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def map_err(&_block)
-        T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
+        self
       end
 
       # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], _block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def map_err_wt(_t_new_err, &_block)
-        T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
+        self
       end
 
-      sig { override.type_parameters(:NewOkType).params(other: Result[T.type_parameter(:NewOkType), ErrType]).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def and(other)
         other
       end
 
-      sig { override.type_parameters(:NewOkType).params(block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def and_then(&block)
         block.call(@inner)
       end
 
-      sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+      # @deprecated
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def and_then_wt(_t_new_ok, &block)
         block.call(@inner)
       end
 
       sig {
         override
+          .type_parameters(:NewErrType)
           .params(
-            new_err_inner: ErrType,
+            new_err_inner: T.type_parameter(:NewErrType),
             condition: T.proc.params(inner: OkType).returns(T::Boolean)
           )
           .returns(
-            Result[OkType, ErrType]
+            Result[OkType, T.type_parameter(:NewErrType)]
           )
       }
       def and_err_if(new_err_inner, &condition)
         if condition.call(@inner)
-          Result::Err[OkType, ErrType].new(new_err_inner)
+          Result::Err[T.type_parameter(:NewErrType)].new(new_err_inner)
         else
           self
         end
       end
 
-      sig { override.params(_other: Result[OkType, ErrType]).returns(Result[OkType, ErrType]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def or(_other)
         self
       end
 
-      sig { override.type_parameters(:NewErrType).params(_block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def or_else(&_block)
-        T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
+        self
       end
 
-      sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], _block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
+      # @deprecated
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], _block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def or_else_wt(_t_new_err, &_block)
-        T.cast(self, Result::Ok[OkType, T.type_parameter(:NewErrType)])
+        self
       end
 
       sig {
         override
+          .type_parameters(:NewOkType)
           .params(
-            _new_ok_inner: OkType,
+            _new_ok_inner: T.type_parameter(:NewOkType),
             _condition: T.proc.params(inner: ErrType).returns(T::Boolean)
           )
           .returns(
-            Result::Ok[OkType, ErrType]
+            Result[OkType, ErrType]
           )
       }
       def or_ok_if(_new_ok_inner, &_condition)
@@ -327,7 +335,7 @@ module Mangrove
 
       include Result
 
-      OkType = type_member
+      OkType = type_member { { fixed: T.noreturn } }
       ErrType = type_member
 
       sig { params(inner: ErrType).void }
@@ -396,90 +404,91 @@ module Mangrove
         block.call(self)
       end
 
-      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T.type_parameter(:NewOkType), _t_new_err: T.type_parameter(:NewErrType), block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: Result[OkType, ErrType]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def map_wt(_t_new_ok, _t_new_err, &block)
         block.call(self)
       end
 
       sig { override.type_parameters(:NewOkType).params(_block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def map_ok(&_block)
-        T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
+        self
       end
 
-      # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _block: T.proc.params(this: OkType).returns(T.type_parameter(:NewOkType))).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def map_ok_wt(_t_new_ok, &_block)
-        T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
+        self
       end
 
       sig { override.type_parameters(:NewErrType).params(block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def map_err(&block)
-        Result::Err[OkType, T.type_parameter(:NewErrType)].new(block.call(@inner))
+        Result::Err[T.type_parameter(:NewErrType)].new(block.call(@inner))
       end
 
-      # Because sorbet does not deduct types from return values well. This method takes a type of new inner values.
       sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(T.type_parameter(:NewErrType))).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
       def map_err_wt(_t_new_err, &block)
-        Result::Err[OkType, T.type_parameter(:NewErrType)].new(block.call(@inner))
+        Result::Err[T.type_parameter(:NewErrType)].new(block.call(@inner))
       end
 
-      sig { override.type_parameters(:NewOkType).params(_other: Result[T.type_parameter(:NewOkType), ErrType]).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def and(_other)
-        T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
+        self
       end
 
-      sig { override.type_parameters(:NewOkType).params(_block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def and_then(&_block)
-        T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
+        self
       end
 
-      sig { override.type_parameters(:NewOkType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), ErrType])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
+      # @deprecated
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_ok: T::Class[T.type_parameter(:NewOkType)], _block: T.proc.params(this: OkType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), ErrType]) }
       def and_then_wt(_t_new_ok, &_block)
-        T.cast(self, Result::Err[T.type_parameter(:NewOkType), ErrType])
+        self
       end
 
       sig {
         override
+          .type_parameters(:NewErrType)
           .params(
-            _new_err_inner: ErrType,
+            _new_err_inner: T.type_parameter(:NewErrType),
             _condition: T.proc.params(inner: OkType).returns(T::Boolean)
           )
           .returns(
-            Result::Err[OkType, ErrType]
+            Result[OkType, ErrType]
           )
       }
       def and_err_if(_new_err_inner, &_condition)
         self
       end
 
-      sig { override.params(other: Result[OkType, ErrType]).returns(Result[OkType, ErrType]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(other: Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def or(other)
         other
       end
 
-      sig { override.type_parameters(:NewErrType).params(block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def or_else(&block)
         block.call(@inner)
       end
 
-      sig { override.type_parameters(:NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[OkType, T.type_parameter(:NewErrType)])).returns(Result[OkType, T.type_parameter(:NewErrType)]) }
+      sig { override.type_parameters(:NewOkType, :NewErrType).params(_t_new_err: T::Class[T.type_parameter(:NewErrType)], block: T.proc.params(this: ErrType).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)])).returns(Result[T.type_parameter(:NewOkType), T.type_parameter(:NewErrType)]) }
       def or_else_wt(_t_new_err, &block)
         block.call(@inner)
       end
 
       sig {
         override
+          .type_parameters(:NewOkType)
           .params(
-            new_ok_inner: OkType,
+            new_ok_inner: T.type_parameter(:NewOkType),
             condition: T.proc.params(inner: ErrType).returns(T::Boolean)
           )
           .returns(
-            Result[OkType, ErrType]
+            Result[T.type_parameter(:NewOkType), ErrType]
           )
       }
       def or_ok_if(new_ok_inner, &condition)
         if condition.call(@inner)
-          Result::Ok[OkType, ErrType].new(new_ok_inner)
+          Result::Ok[T.type_parameter(:NewOkType)].new(new_ok_inner)
         else
           self
         end

data/lib/mangrove/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Mangrove
-  VERSION = "0.24.0"
+  VERSION = "0.30.0"
 end

data/rbi/mangrove.rbi

@@ -0,0 +1,20 @@
+# typed: true
+
+module Mangrove
+  # Result is a type that represents either success (`Ok`) or failure (`Err`).
+  module Result
+    class Err
+      class << self
+        sig { type_parameters(:ErrType).params(inner: T.type_parameter(:ErrType)).returns(Mangrove::Result::Err[T.type_parameter(:ErrType)]) }
+        def new(inner); end
+      end
+    end
+
+    class Ok
+      class << self
+        sig { type_parameters(:OkType).params(inner: T.type_parameter(:OkType)).returns(Mangrove::Result::Ok[T.type_parameter(:OkType)]) }
+        def new(inner); end
+      end
+    end
+  end
+end

data/sorbet/rbi/annotations/rainbow.rbi

@@ -60,14 +60,14 @@ module Rainbow
     class X11Named < Rainbow::Color::RGB
       include Rainbow::X11ColorNames
 
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
       sig { returns(T::Array[Symbol]) }
       def self.color_names; end
 
       sig { returns(String) }
       def self.valid_names; end
-
-      sig { params(ground: Symbol, name: Symbol).void }
-      def initialize(ground, name); end
     end
   end