mayak 0.0.3 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b0f6dd0284a5fcb3319c3c809fac92a1f071115495ea492deee12687023413
-  data.tar.gz: d2ec0d4a48f29136f159553233b846f56d998f79852bfad962aee7ba6b09cfbb
+  metadata.gz: be2462b16e6c760e1eafcfe6463646b3d7615bcc77bb68a6e391f78676b6c85d
+  data.tar.gz: 433b79c42704dbd28cd90f0f6af0fe927975a50870af96fa89d850d3dafa3bda
 SHA512:
-  metadata.gz: ac0b20d7a23fab465f1fb460a0a5866a411c4c3874e557ceb82bca724af63f55cb7c0c582fa61c392362b72be01447851895f8b17cceb674a0874dfa91ab92aa
-  data.tar.gz: a1598a89492189ee4fc70b4cabc54898164ca6ddd9b23d00dc66c578c105180b02d3cc0245cfe71069fad75938e04eea60277cb6f7e722d8b005f14bd1cfaa71
+  metadata.gz: 8fad1350834462ba9d7563f337bb7c08fb92d4f1a0c0a0620993fb9d5c574374ee6fc1a74b14689189c8a5effa926dd50376fb646ec0b63f1cbd94d0720d16ff
+  data.tar.gz: 2e7713b90c86e46fcf3c2fa9abe6cf1b381b26267733a57664553101090fc72f288a282896a8e4f489e193d08f6266a32d515cfaba8e83ff758e3d06ad7ecfa3

data/lib/mayak/http/request.rb

@@ -18,7 +18,7 @@ module Mayak
 
       sig(:final) { params(other: Mayak::Http::Request).returns(T::Boolean) }
       def ==(other)
-        verb == other.verb && url.to_s == other.url.to_s && headers && other.headers && body == other.body
+        verb == other.verb && url.to_s == other.url.to_s && headers == other.headers && body == other.body
       end
 
       sig(:final) { params(other: Mayak::Http::Request).returns(T::Boolean) }

data/lib/mayak/monads/README.md

@@ -98,33 +98,47 @@ divide(10, 2).value_or(0) # 5
 divide(10, 0).value_or(0) # 0
 ```
 
-### Methods
-
-#### `#to_dry`
-
-Converts an instance of a monad in to an instance of corresponding dry-monad.
-
+Note that the type of value passed into `value_or` shouldn't necessarily be of the same type as `Maybe`. If it doesn't match
+the result type of method invokation will be union of `Maybe` type and type of value passed:
 ```ruby
-include Mayak::Monads::Maybe::Mixin
+result = divide(10, 2).value_or("None")
+T.reveal_type(result) # T.any(String, Integer)
+```
 
-Maybe(10).to_dry  # Some(10): Dry::Monads::Maybe::Some
-Maybe(nil).to_dry # None:  Dry::Monads::Maybe::None
+You can also pass `nil` into `value_or`, and the result type of the expression will `T.nilable` type:
+```ruby
+result = divide(10, 2).value_or(nil)
+T.reveal_type(result) # T.nilable(Integer)
 ```
 
-#### `.from_dry`
+### Methods
+
+#### `#either`
 
-Converts instance of `Dry::Monads::Maybe` into instance `Mayak::Monads::Maybe`
+Receives two lambda functions representing branches: none-branch, and some-branch. If a `Maybe` is `None` than none-branch will be executedand result of method invokation will be a result of none-branch execution. If a `Maybe` is `Some` than some-branch will be executed with a value of monad and result of method invokation will be a result of some-branch execution.
 
 ```ruby
-include Mayak::Monads
+divide(10, 2).either(
+  -> { 0 },
+  -> (value) { value * 100 }
+) # 50
 
-Maybe.from_dry(Dry::Monads::Some(10)) # Some[Integer](value = 20)
-Maybe.from_dry(Dry::Monads::None())   # None
+
+divide(10, 0).either(
+  -> { 0 },
+  -> (value) { value * 100 }
+) # 0
+
+result = divide(10, 0).either(
+  -> { "Error" },
+  -> (value) { value * 100 }
+)
+T.reveal_type(result) # T.any(String, Integer)
 ```
 
 #### `#map`
 
-The same as `fmap` in a dry-monads `Maybe`. Allows to modify the value with a block if it's present.
+The same as `fmap` in a dry-monads `Maybe`. Allows to modify the value inside the `Maybe` with a block if it's present. Returns `Maybe` itself.
 
 ```ruby
 sig { returns(Mayak::Monads::Maybe[Integer]) }
@@ -621,33 +635,6 @@ Try { raise "Boom" }.failure_or(StandardError.new("Error")) # #<StandardError: B
 
 ### Methods
 
-#### `#to_dry`
-
-Converts an instance of a monad in to an instance of corresponding dry-monad.
-
-```ruby
-include Mayak::Monads::Try::Mixin
-
-Try { 10 }.to_dry  # Try::Value(10)
-Try { raise "Error" }.to_dry # Try::Error(RuntimeError: Error)
-```
-
-
-#### `.from_dry`
-
-Converts instance of `Dry::Monads::Try` into instance `Mayak::Monads::Try`
-
-```ruby
-include Mayak::Monads
-
-error = StandardError.new("Error")
-Try.from_dry(Dry::Monads::Try::Value.new([StandardError], 10)) # Try::Success[T.untyped](value = 10)
-Try.from_dry(Dry::Monads::Try::Error.new(error))   # Try::Failure[T.untyped](error=#<StandardError: Error>)
-```
-
-Unfortunately `.from_dry` doesn't preserve types due to the way `Dry::Monads::Try` is written, so
-this method always returns `Mayak::Monads::Try[T.untyped]`.
-
 #### `#map`
 
 The same as `fmap` in a dry-monads `Try`. Allows to modify the value with a block if it's present.
@@ -1088,38 +1075,6 @@ Result::Failure[String, Integer].new("Error").failure_or("Another Error") # "Err
 
 ### Methods
 
-#### `#to_dry`
-
-Converts an instance of a monad in to an instance of corresponding dry-monad.
-
-```ruby
-Result::Success[String, Integer].new(10).to_dry      # Success(10): Dry::Monads::Result::Success
-Result::Failure[String, Integer].new("Error").to_dry # Failure("Error"): Dry::Monads::Result::Failure
-```
-
-
-#### `.from_dry`
-
-Converts instance of `Dry::Monads::Result` into instance `Mayak::Monads::Result`
-
-```ruby
-sig { returns(Dry::Monads::Result::Success[String, Integer]) }
-def dry_success
-  Dry::Monads::Result::Success.new(10)
-end
-
-sig { returns(Dry::Monads::Result::Success[String, Integer]) }
-def dry_failure
-  Dry::Monads::Result::Failure.new("Error")
-end
-
-Try.from_dry(dry_success) # Mayak::Monads::Result::Success[String, Integer](value = 10)
-Try.from_dry(dry_failure) # Mayak::Monads::Result::Success[String, Integer]("Error")
-```
-
-Unfortunately `.from_dry` doesn't preserve types due to the way `Dry::Monads::Try` is written, so
-this method always returns `Mayak::Monads::Try[T.untyped]`.
-
 #### `#map`
 
 The same as `fmap` in a dry-monads `Result`. Allows to modify the value with a block if it's present.

data/lib/mayak/monads/maybe.rb

@@ -11,7 +11,7 @@ module Mayak
       abstract!
       sealed!
 
-      Value = type_member
+      Value = type_member(:out)
 
       sig {
         abstract
@@ -49,7 +49,12 @@ module Mayak
       def none?
       end
 
-      sig { abstract.params(value: Value).returns(Value) }
+      sig {
+        abstract
+          .type_parameters(:AnotherValue)
+          .params(value: T.type_parameter(:AnotherValue))
+          .returns(T.any(T.type_parameter(:AnotherValue), Value))
+      }
       def value_or(value)
       end
 
@@ -63,11 +68,13 @@ module Mayak
 
       sig {
         abstract
-          .type_parameters(:Result)
-          .params(fallback: T.type_parameter(:Result), blk: T.proc.params(arg0: Value).returns(T.type_parameter(:Result)))
-          .returns(T.type_parameter(:Result))
+          .type_parameters(:NoneResult, :SomeResult)
+          .params(
+            none_branch: T.proc.returns(T.type_parameter(:NoneResult)),
+            some_branch: T.proc.params(arg0: Value).returns(T.type_parameter(:SomeResult))
+          ).returns(T.any(T.type_parameter(:NoneResult), T.type_parameter(:SomeResult)))
       }
-      def either(fallback, &blk)
+      def either(none_branch, some_branch)
       end
 
       sig {
@@ -92,10 +99,24 @@ module Mayak
         map { |_| new_value }
       end
 
-      sig { abstract.params(value: Value).returns(Maybe[Value]) }
+      sig {
+        type_parameters(:NewValue)
+          .abstract
+          .params(value: T.type_parameter(:NewValue))
+          .returns(Maybe[T.any(T.type_parameter(:NewValue), Value)])
+      }
       def recover(value)
       end
 
+      sig {
+        type_parameters(:NewValue)
+          .abstract
+          .params(maybe: Maybe[T.type_parameter(:NewValue)])
+          .returns(Maybe[T.any(T.type_parameter(:NewValue), Value)])
+      }
+      def recover_with_maybe(maybe)
+      end
+
       sig(:final) { params(another: Mayak::Monads::Maybe[T.untyped]).returns(T::Boolean) }
       def ==(another)
         case self
@@ -212,7 +233,12 @@ module Mayak
           false
         end
 
-        sig(:final) { override.params(value: Value).returns(Value) }
+        sig(:final) {
+          override
+            .type_parameters(:AnotherValue)
+            .params(value: T.any(T.type_parameter(:AnotherValue), Value))
+            .returns(T.any(T.type_parameter(:AnotherValue), Value))
+        }
         def value_or(value)
           @value
         end
@@ -229,12 +255,14 @@ module Mayak
 
         sig(:final) {
           override
-            .type_parameters(:Result)
-            .params(fallback: T.type_parameter(:Result), blk: T.proc.params(arg0: Value).returns(T.type_parameter(:Result)))
-            .returns(T.type_parameter(:Result))
+            .type_parameters(:NoneResult, :SomeResult)
+            .params(
+              none_branch: T.proc.returns(T.type_parameter(:NoneResult)),
+              some_branch: T.proc.params(arg0: Value).returns(T.type_parameter(:SomeResult))
+            ).returns(T.any(T.type_parameter(:NoneResult), T.type_parameter(:SomeResult)))
         }
-        def either(fallback, &blk)
-          blk.call(@value)
+        def either(none_branch, some_branch)
+          some_branch.call(@value)
         end
 
         sig(:final) {
@@ -252,10 +280,25 @@ module Mayak
           Mayak::Monads::Try::Success.new(@value)
         end
 
-        sig(:final) { override.params(value: Value).returns(Maybe[Value]) }
+        sig(:final) {
+          type_parameters(:NewValue)
+            .override
+            .params(value: T.type_parameter(:NewValue))
+            .returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
+        }
         def recover(value)
           self
         end
+
+        sig(:final) {
+          type_parameters(:NewValue)
+            .override
+            .params(maybe: Maybe[T.type_parameter(:NewValue)])
+            .returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
+        }
+        def recover_with_maybe(maybe)
+          self
+        end
       end
 
       class None
@@ -314,7 +357,12 @@ module Mayak
           true
         end
 
-        sig(:final) { override.params(value: Value).returns(Value) }
+        sig(:final) {
+          override
+            .type_parameters(:AnotherValue)
+            .params(value: T.any(T.type_parameter(:AnotherValue), Value))
+            .returns(T.any(T.type_parameter(:AnotherValue), Value))
+        }
         def value_or(value)
           value
         end
@@ -330,12 +378,14 @@ module Mayak
 
         sig(:final) {
           override
-            .type_parameters(:Result)
-            .params(fallback: T.type_parameter(:Result), blk: T.proc.params(arg0: Value).returns(T.type_parameter(:Result)))
-            .returns(T.type_parameter(:Result))
+            .type_parameters(:NoneResult, :SomeResult)
+            .params(
+              none_branch: T.proc.returns(T.type_parameter(:NoneResult)),
+              some_branch: T.proc.params(arg0: Value).returns(T.type_parameter(:SomeResult))
+            ).returns(T.any(T.type_parameter(:NoneResult), T.type_parameter(:SomeResult)))
         }
-        def either(fallback, &blk)
-          fallback
+        def either(none_branch, some_branch)
+          none_branch.call
         end
 
         sig(:final) {
@@ -353,10 +403,25 @@ module Mayak
           Mayak::Monads::Try::Failure.new(error)
         end
 
-        sig(:final) { override.params(value: Value).returns(Maybe[Value]) }
+        sig(:final) {
+          type_parameters(:NewValue)
+            .override
+            .params(value: T.type_parameter(:NewValue))
+            .returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
+        }
         def recover(value)
           Mayak::Monads::Maybe::Some.new(value)
         end
+
+        sig(:final) {
+          type_parameters(:NewValue)
+            .override
+            .params(maybe: Maybe[T.type_parameter(:NewValue)])
+            .returns(Maybe[T.any(Value, T.type_parameter(:NewValue))])
+        }
+        def recover_with_maybe(maybe)
+          maybe
+        end
       end
 
       module Mixin

data/lib/mayak/monads/result.rb

@@ -11,8 +11,8 @@ module Mayak
       abstract!
       sealed!
 
-      FailureType = type_member
-      SuccessType = type_member
+      FailureType = type_member(:out)
+      SuccessType = type_member(:out)
 
       sig {
         abstract
@@ -24,20 +24,21 @@ module Mayak
       end
 
       sig {
-        abstract
-          .type_parameters(:NewSuccess)
+        type_parameters(:NewSuccess, :NewFailure)
+          .abstract
           .params(
-            blk: T.proc.params(arg0: SuccessType).returns(Result[FailureType, T.type_parameter(:NewSuccess)])
+            blk: T.proc.params(arg0: SuccessType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
           )
-          .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
+          .returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), T.type_parameter(:NewSuccess)])
       }
       def flat_map(&blk)
       end
 
       sig {
-        abstract
-          .params(error: FailureType, blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
-          .returns(Result[FailureType, SuccessType])
+        type_parameters(:NewSuccess, :NewFailure)
+          .abstract
+          .params(error: T.type_parameter(:NewFailure), blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
+          .returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType])
       }
       def filter_or(error, &blk)
       end
@@ -50,11 +51,21 @@ module Mayak
       def failure?
       end
 
-      sig { abstract.params(value: SuccessType).returns(SuccessType) }
+      sig {
+        abstract
+          .type_parameters(:NewSuccessType)
+          .params(value: T.type_parameter(:NewSuccessType))
+          .returns(T.any(T.type_parameter(:NewSuccessType), SuccessType))
+      }
       def success_or(value)
       end
 
-      sig { abstract.params(value: FailureType).returns(FailureType) }
+      sig {
+        abstract
+          .type_parameters(:NewFailureType)
+          .params(value: T.type_parameter(:NewFailureType))
+          .returns(T.any(T.type_parameter(:NewFailureType), FailureType))
+      }
       def failure_or(value)
       end
 
@@ -118,11 +129,11 @@ module Mayak
 
       sig {
         abstract
-          .type_parameters(:NewFailure)
+          .type_parameters(:NewFailure, :NewSuccess)
           .params(
-            blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
+            blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
           ).returns(
-            Result[T.type_parameter(:NewFailure), SuccessType]
+            Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
           )
       }
       def flat_map_failure(&blk)
@@ -158,28 +169,30 @@ module Mayak
       end
 
       sig {
-        abstract
-          .params(value: SuccessType)
-          .returns(Result[FailureType, SuccessType])
+        type_parameters(:NewSuccess)
+          .abstract
+          .params(value: T.type_parameter(:NewSuccess))
+          .returns(Result[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)])
       }
       def recover(value)
       end
 
       sig {
-        abstract
-          .params(blk: T.proc.params(arg0: FailureType).returns(SuccessType))
-          .returns(Result[FailureType, SuccessType])
+        type_parameters(:NewSuccessType)
+          .abstract
+          .params(blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewSuccessType)))
+          .returns(Result[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))])
       }
       def recover_with(&blk)
       end
 
       sig {
         abstract
-          .type_parameters(:NewFailure)
+          .type_parameters(:NewFailure, :NewSuccess)
           .params(
-            blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
+            blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
           ).returns(
-            Result[T.type_parameter(:NewFailure), SuccessType]
+            Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
           )
       }
       def recover_with_result(&blk)
@@ -237,28 +250,30 @@ module Mayak
           Mayak::Monads::Result::Success.new(blk.call(@success_value))
         end
 
+
         sig(:final) {
           override
-            .type_parameters(:NewSuccess)
+            .type_parameters(:NewSuccess, :NewFailure)
             .params(
-              blk: T.proc.params(arg0: SuccessType).returns(Result[FailureType, T.type_parameter(:NewSuccess)])
+              blk: T.proc.params(arg0: SuccessType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
             )
-            .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
+            .returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), T.type_parameter(:NewSuccess)])
         }
         def flat_map(&blk)
           blk.call(@success_value)
         end
 
         sig(:final) {
-          override
-            .params(error: FailureType, blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
-            .returns(Result[FailureType, SuccessType])
+          type_parameters(:NewSuccess, :NewFailure)
+            .override
+            .params(error: T.type_parameter(:NewFailure), blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
+            .returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType])
         }
         def filter_or(error, &blk)
           if blk.call(@success_value)
             self
           else
-            Mayak::Monads::Result::Failure[FailureType, SuccessType].new(error)
+            ::Mayak::Monads::Result::Failure[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType].new(error)
           end
         end
 
@@ -277,12 +292,22 @@ module Mayak
           false
         end
 
-        sig(:final) { override.params(value: SuccessType).returns(SuccessType) }
+        sig(:final) {
+          override
+            .type_parameters(:NewSuccessType)
+            .params(value: T.type_parameter(:NewSuccessType))
+            .returns(T.any(T.type_parameter(:NewSuccessType), SuccessType))
+        }
         def success_or(value)
           @success_value
         end
 
-        sig(:final) { override.params(value: FailureType).returns(FailureType) }
+        sig(:final) {
+          override
+            .type_parameters(:NewFailureType)
+            .params(value: T.any(T.type_parameter(:NewFailureType), FailureType))
+            .returns(T.any(T.type_parameter(:NewFailureType), FailureType))
+        }
         def failure_or(value)
           value
         end
@@ -347,12 +372,12 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .type_parameters(:NewFailure)
+          type_parameters(:NewFailure, :NewSuccess)
+            .override
             .params(
-              blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
+              blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
             ).returns(
-              Result[T.type_parameter(:NewFailure), SuccessType]
+              Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
             )
         }
         def flat_map_failure(&blk)
@@ -363,28 +388,33 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .params(value: SuccessType)
-            .returns(Result[FailureType, SuccessType])
+          type_parameters(:NewSuccess)
+            .override
+            .params(value: T.type_parameter(:NewSuccess))
+            .returns(Result[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)])
         }
         def recover(value)
           self
         end
 
         sig(:final) {
-          override
-            .params(blk: T.proc.params(arg0: FailureType).returns(SuccessType))
-            .returns(Result[FailureType, SuccessType])
+          type_parameters(:NewSuccessType)
+            .override
+            .params(blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewSuccessType)))
+            .returns(Result[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))])
         }
         def recover_with(&blk)
           self
         end
 
         sig(:final) {
-          override
-            .type_parameters(:NewFailure)
-            .params(blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType]))
-            .returns(Result[T.type_parameter(:NewFailure), SuccessType])
+          type_parameters(:NewFailure, :NewSuccess)
+            .override
+            .params(
+              blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
+            ).returns(
+              Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
+            )
         }
         def recover_with_result(&blk)
           T.cast(
@@ -426,11 +456,11 @@ module Mayak
 
         sig(:final) {
           override
-            .type_parameters(:NewSuccess)
+            .type_parameters(:NewSuccess, :NewFailure)
             .params(
-              blk: T.proc.params(arg0: SuccessType).returns(Result[FailureType, T.type_parameter(:NewSuccess)])
+              blk: T.proc.params(arg0: SuccessType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
             )
-            .returns(Result[FailureType, T.type_parameter(:NewSuccess)])
+            .returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), T.type_parameter(:NewSuccess)])
         }
         def flat_map(&blk)
           T.cast(
@@ -440,9 +470,10 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .params(error: FailureType, blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
-            .returns(Result[FailureType, SuccessType])
+          type_parameters(:NewSuccess, :NewFailure)
+            .override
+            .params(error: T.type_parameter(:NewFailure), blk: T.proc.params(arg0: SuccessType).returns(T::Boolean))
+            .returns(Result[T.any(FailureType, T.type_parameter(:NewFailure)), SuccessType])
         }
         def filter_or(error, &blk)
           self
@@ -463,12 +494,22 @@ module Mayak
           true
         end
 
-        sig(:final) { override.params(value: SuccessType).returns(SuccessType) }
+        sig(:final) {
+          override
+            .type_parameters(:NewSuccessType)
+            .params(value: T.type_parameter(:NewSuccessType))
+            .returns(T.any(T.type_parameter(:NewSuccessType), SuccessType))
+        }
         def success_or(value)
           value
         end
 
-        sig(:final) { override.params(value: FailureType).returns(FailureType) }
+        sig(:final) {
+          override
+            .type_parameters(:NewFailureType)
+            .params(value: T.any(T.type_parameter(:NewFailureType), FailureType))
+            .returns(T.any(T.type_parameter(:NewFailureType), FailureType))
+        }
         def failure_or(value)
           @failure_value
         end
@@ -529,12 +570,12 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .type_parameters(:NewFailure)
+          type_parameters(:NewFailure, :NewSuccess)
+            .override
             .params(
-              blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType])
+              blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
             ).returns(
-              Result[T.type_parameter(:NewFailure), SuccessType]
+              Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
             )
         }
         def flat_map_failure(&blk)
@@ -542,28 +583,36 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .params(value: SuccessType)
-            .returns(Result[FailureType, SuccessType])
+          type_parameters(:NewSuccess)
+            .override
+            .params(value: T.type_parameter(:NewSuccess))
+            .returns(Result[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)])
         }
         def recover(value)
-          Mayak::Monads::Result::Success[FailureType, SuccessType].new(value)
+          ::Mayak::Monads::Result::Success[FailureType, T.any(T.type_parameter(:NewSuccess), SuccessType)].new(value)
         end
 
+
         sig(:final) {
-          override
-            .params(blk: T.proc.params(arg0: FailureType).returns(SuccessType))
-            .returns(Result[FailureType, SuccessType])
+          type_parameters(:NewSuccessType)
+            .override
+            .params(blk: T.proc.params(arg0: FailureType).returns(T.type_parameter(:NewSuccessType)))
+            .returns(Result[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))])
         }
         def recover_with(&blk)
-          Mayak::Monads::Result::Success[FailureType, SuccessType].new(blk.call(@failure_value))
+          ::Mayak::Monads::Result::Success[FailureType, T.any(SuccessType, T.type_parameter(:NewSuccessType))].new(
+            blk.call(@failure_value)
+          )
         end
 
         sig(:final) {
-          override
-            .type_parameters(:NewFailure)
-            .params(blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), SuccessType]))
-            .returns(Result[T.type_parameter(:NewFailure), SuccessType])
+          type_parameters(:NewFailure, :NewSuccess)
+            .override
+            .params(
+              blk: T.proc.params(arg0: FailureType).returns(Result[T.type_parameter(:NewFailure), T.type_parameter(:NewSuccess)])
+            ).returns(
+              Result[T.type_parameter(:NewFailure), T.any(T.type_parameter(:NewSuccess), SuccessType)]
+            )
         }
         def recover_with_result(&blk)
           blk.call(@failure_value)

data/lib/mayak/monads/try.rb

@@ -10,7 +10,7 @@ module Mayak
       abstract!
       sealed!
 
-      Value = type_member
+      Value = type_member(:out)
 
       sig {
         abstract
@@ -48,7 +48,12 @@ module Mayak
       def failure?
       end
 
-      sig { abstract.params(value: Value).returns(Value) }
+      sig {
+        abstract
+          .type_parameters(:NewValue)
+          .params(value: T.type_parameter(:NewValue))
+          .returns(T.any(T.type_parameter(:NewValue), Value))
+      }
       def success_or(value)
       end
 
@@ -86,9 +91,10 @@ module Mayak
       end
 
       sig {
-        abstract
-          .params(blk: T.proc.params(arg0: StandardError).returns(Try[Value]))
-          .returns(Try[Value])
+        type_parameters(:NewValue)
+          .abstract
+          .params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
+          .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
       }
       def flat_map_failure(&blk)
       end
@@ -141,34 +147,39 @@ module Mayak
       end
 
       sig {
-        abstract
-          .params(value: Value)
-          .returns(Try[Value])
+        type_parameters(:NewValue)
+          .abstract
+          .params(value: T.type_parameter(:NewValue))
+          .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
       }
       def recover(value)
       end
 
       sig {
-        abstract
-          .params(blk: T.proc.params(arg0: StandardError).returns(Value))
-          .returns(Try[Value])
+        type_parameters(:NewValue)
+          .abstract
+          .params(blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue)))
+          .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
       }
       def recover_with(&blk)
       end
 
       sig {
-        abstract
+        type_parameters(:NewValue)
+          .abstract
           .params(
             error_type: T.class_of(StandardError),
-            blk: T.proc.params(arg0: StandardError).returns(Value)
+            blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue))
           )
-          .returns(Try[Value])
+          .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
       }
       def recover_on(error_type, &blk)
       end
 
       sig(:final) {
-        params(blk: T.proc.params(arg0: StandardError).returns(Try[Value])).returns(Try[Value])
+        type_parameters(:NewValue)
+          .params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
+          .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
       }
       def recover_with_try(&blk)
         flat_map_failure(&blk)
@@ -272,7 +283,12 @@ module Mayak
           false
         end
 
-        sig(:final) { override.params(value: Value).returns(Value) }
+        sig(:final) {
+          override
+            .type_parameters(:NewValue)
+            .params(value: T.any(T.type_parameter(:NewValue), Value))
+            .returns(T.any(T.type_parameter(:NewValue), Value))
+        }
         def success_or(value)
           @value
         end
@@ -316,9 +332,10 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .params(blk: T.proc.params(arg0: StandardError).returns(Try[Value]))
-            .returns(Try[Value])
+          type_parameters(:NewValue)
+            .override
+            .params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
         }
         def flat_map_failure(&blk)
           self
@@ -340,27 +357,34 @@ module Mayak
         end
 
         sig(:final) {
-          override
+          type_parameters(:NewValue)
+            .override
             .params(
               error_type: T.class_of(StandardError),
-              blk: T.proc.params(arg0: StandardError).returns(Value)
+              blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue))
             )
-            .returns(Try[Value])
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
         }
         def recover_on(error_type, &blk)
           self
         end
 
         sig(:final) {
-          override
-            .params(value: Value)
-            .returns(Try[Value])
+          type_parameters(:NewValue)
+            .override
+            .params(value: T.type_parameter(:NewValue))
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
         }
         def recover(value)
           self
         end
 
-        sig(:final) { override.params(blk: T.proc.params(arg0: StandardError).returns(Value)).returns(Try[Value]) }
+        sig(:final) {
+          type_parameters(:NewValue)
+            .override
+            .params(blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue)))
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
+        }
         def recover_with(&blk)
           self
         end
@@ -431,7 +455,12 @@ module Mayak
           true
         end
 
-        sig(:final) { override.params(value: Value).returns(Value) }
+        sig(:final) {
+          override
+            .type_parameters(:NewValue)
+            .params(value: T.any(T.type_parameter(:NewValue), Value))
+            .returns(T.any(T.type_parameter(:NewValue), Value))
+        }
         def success_or(value)
           value
         end
@@ -474,9 +503,10 @@ module Mayak
         end
 
         sig(:final) {
-          override
-            .params(blk: T.proc.params(arg0: StandardError).returns(Try[Value]))
-            .returns(Try[Value])
+          type_parameters(:NewValue)
+            .override
+            .params(blk: T.proc.params(arg0: StandardError).returns(Try[T.type_parameter(:NewValue)]))
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
         }
         def flat_map_failure(&blk)
           blk.call(@failure)
@@ -494,37 +524,44 @@ module Mayak
 
         sig(:final) { override.returns(Mayak::Monads::Maybe[Value]) }
         def to_maybe
-          Mayak::Monads::Maybe::None.new
+          ::Mayak::Monads::Maybe::None[Value].new
         end
 
         sig(:final) {
-          override
+          type_parameters(:NewValue)
+            .override
             .params(
               error_type: T.class_of(StandardError),
-              blk: T.proc.params(arg0: StandardError).returns(Value)
+              blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue))
             )
-            .returns(Try[Value])
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
         }
         def recover_on(error_type, &blk)
           if @failure.is_a?(error_type)
-            Mayak::Monads::Try::Success[Value].new(blk.call(@failure))
+            ::Mayak::Monads::Try::Success[T.any(T.type_parameter(:NewValue), Value)].new(blk.call(@failure))
           else
             self
           end
         end
 
         sig(:final) {
-          override
-            .params(value: Value)
-            .returns(Try[Value])
+          type_parameters(:NewValue)
+            .override
+            .params(value: T.type_parameter(:NewValue))
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
         }
         def recover(value)
-          Mayak::Monads::Try::Success[Value].new(value)
+          ::Mayak::Monads::Try::Success[T.any(T.type_parameter(:NewValue), Value)].new(value)
         end
 
-        sig(:final) { override.params(blk: T.proc.params(arg0: StandardError).returns(Value)).returns(Try[Value]) }
+        sig(:final) {
+          type_parameters(:NewValue)
+            .override
+            .params(blk: T.proc.params(arg0: StandardError).returns(T.type_parameter(:NewValue)))
+            .returns(Try[T.any(T.type_parameter(:NewValue), Value)])
+        }
         def recover_with(&blk)
-          Mayak::Monads::Try::Success[Value].new(blk.call(@failure))
+          ::Mayak::Monads::Try::Success[T.any(T.type_parameter(:NewValue), Value)].new(blk.call(@failure))
         end
       end
 

data/lib/mayak/numeric.rb

@@ -37,10 +37,17 @@ module Mayak
       when BigDecimal
         Mayak::Monads::Maybe::Some[BigDecimal].new(value)
       when Float
-        Mayak::Monads::Maybe::Some[BigDecimal].new(value.to_d)
+        Mayak::Monads::Maybe::Some[BigDecimal].new(BigDecimal(value, Float::DIG + 1))
       end
     rescue ArgumentError, TypeError
       Mayak::Monads::Maybe::None[BigDecimal].new
     end
+
+    sig { params(value: BigDecimal, total: BigDecimal).returns(BigDecimal) }
+    def self.percent_of(value:, total:)
+      return BigDecimal(0) if total.zero?
+
+      value / total * BigDecimal(100)
+    end
   end
 end

data/mayak.gemspec

@@ -4,7 +4,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "mayak"
-  spec.version       = "0.0.3"
+  spec.version       = "0.0.6"
   spec.summary       = "Set of fully typed utility classes and interfaces integrated with Sorbet."
   spec.description   = spec.summary
   spec.authors       = ["Daniil Bober"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mayak
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.6
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2024-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime