mayak 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a36466c4a142e690196d7f63f0adbca6287b6ba1772309948cce797f3dfdf24d
-  data.tar.gz: 176703f0c3c2d1d95f4653bfc6aa65a10eb3c876d823d95882331699166a6de9
+  metadata.gz: 5e0f62a1884888e93ab1375ff4a8f240b53a7886228ff9bbd6750ccb7cc68705
+  data.tar.gz: cd02858a1b245c5060f94923b1cf8bc4f490dc92768b388da369ce8ef38c4cc5
 SHA512:
-  metadata.gz: ee26f758734c1dbc67390edf6ec6227f6bafc337ece3c54b8fd6b17a8b270382fa39527c096796ec053dc3dc8738fe73f7974a2609fbaf872ec0f3c5e8f9df9b
-  data.tar.gz: 02e9e4b30fae37c91e9dfdaed064b081601c43b06321537d81f78fbfcc19a54c5be20f4ac91f78f421aacdfb846626345bde0de750f0e563be10b84f25b30be2
+  metadata.gz: c4dc1ffc9f62a1958f7f50849298cb3e38992bb727b7015ab480248ed314beef0ad5d5480483219c9ee4298d95e51ad7f644bbe6b99fb32abb65792d9f79477c
+  data.tar.gz: 65a3581b578d4192e21dda936d6b431b5d29d6b31941c98ed626223203a3d5781d3d497c2ab322c9b6653ad04120f9209d9e6503240e050740b2239a968988fe

data/lib/mayak/failable_function.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  class FailableFunction
+    extend T::Sig
+    extend T::Helpers
+    extend T::Generic
+
+    Input  = type_member
+    Output = type_member
+
+    sig { params(blk: T.proc.params(input: Input).returns(Mayak::Monads::Try[Output])).void }
+    def initialize(&blk)
+      @blk = T.let(blk, T.proc.params(input: Input).returns(Mayak::Monads::Try[Output]))
+    end
+
+    sig {
+      type_parameters(
+        :Input,
+        :Output
+      ).params(
+        proc: T.proc.params(
+          arg0: T.type_parameter(:Input)
+        ).returns(
+          ::Mayak::Monads::Try[T.type_parameter(:Output)]
+        )
+      ).returns(
+        ::Mayak::FailableFunction[T.type_parameter(:Input), T.type_parameter(:Output)]
+      )
+    }
+    def self.from_proc(proc)
+      ::Mayak::FailableFunction[T.type_parameter(:Input), T.type_parameter(:Output)].new { |input| proc.call(input) }
+    end
+
+    sig { params(input: Input).returns(Mayak::Monads::Try[Output]) }
+    def call(input)
+      @blk.call(input)
+    end
+
+    sig { returns(T.proc.params(arg0: Input).returns(Mayak::Monads::Try[Output])) }
+    def to_proc
+      -> (input) { call(input) }
+    end
+
+    sig { returns(Mayak::Function[Input, Mayak::Monads::Try[Output]]) }
+    def to_function
+      Mayak::Function[Input, Mayak::Monads::Try[Output]].new { |input| call(input) }
+    end
+
+    sig {
+      type_parameters(:Output2)
+        .params(another: Mayak::FailableFunction[Output, T.type_parameter(:Output2)])
+        .returns(Mayak::FailableFunction[Input, T.type_parameter(:Output2)])
+    }
+    def and_then(another)
+      Mayak::FailableFunction[Input, T.type_parameter(:Output2)].new do |input|
+        @blk.call(input).flat_map { |output| another.call(output) }
+      end
+    end
+    alias >> and_then
+
+    sig {
+      type_parameters(:Input2)
+        .params(another: Mayak::FailableFunction[T.type_parameter(:Input2), Input])
+        .returns(Mayak::FailableFunction[T.type_parameter(:Input2), Output])
+    }
+    def compose(another)
+      Mayak::FailableFunction[T.type_parameter(:Input2), Output].new { |input| another.call(input).flat_map { |new_input| @blk.call(new_input) } }
+    end
+    alias << compose
+
+    sig {
+      type_parameters(
+        :Input,
+        :Output
+      ).params(
+        function: Mayak::Function[T.type_parameter(:Input), Mayak::Monads::Try[T.type_parameter(:Output)]]
+      ).returns(
+        Mayak::FailableFunction[T.type_parameter(:Input), T.type_parameter(:Output)]
+      )
+    }
+    def self.from_function(function)
+      Mayak::FailableFunction[T.type_parameter(:Input), T.type_parameter(:Output)].new { |input| function.call(input) }
+    end
+  end
+end

data/lib/mayak/optional_function.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  class OptionalFunction
+    extend T::Sig
+    extend T::Helpers
+    extend T::Generic
+
+    Input  = type_member
+    Output = type_member
+
+    sig { params(blk: T.proc.params(input: Input).returns(Mayak::Monads::Maybe[Output])).void }
+    def initialize(&blk)
+      @blk = T.let(blk, T.proc.params(input: Input).returns(Mayak::Monads::Maybe[Output]))
+    end
+
+    sig { params(input: Input).returns(Mayak::Monads::Maybe[Output]) }
+    def call(input)
+      @blk.call(input)
+    end
+
+    sig { returns(T.proc.params(arg0: Input).returns(Mayak::Monads::Maybe[Output])) }
+    def to_proc
+      -> (input) { call(input) }
+    end
+
+    sig { returns(Mayak::Function[Input, Mayak::Monads::Maybe[Output]]) }
+    def to_function
+      Mayak::Function[Input, Mayak::Monads::Maybe[Output]].new { |input| call(input) }
+    end
+
+    sig {
+      type_parameters(:Output2)
+        .params(another: Mayak::OptionalFunction[Output, T.type_parameter(:Output2)])
+        .returns(Mayak::OptionalFunction[Input, T.type_parameter(:Output2)])
+    }
+    def and_then(another)
+      Mayak::OptionalFunction[Input, T.type_parameter(:Output2)].new do |input|
+        @blk.call(input).flat_map { |output| another.call(output) }
+      end
+    end
+    alias >> and_then
+
+    sig {
+      type_parameters(:Input2)
+        .params(another: Mayak::OptionalFunction[T.type_parameter(:Input2), Input])
+        .returns(Mayak::OptionalFunction[T.type_parameter(:Input2), Output])
+    }
+    def compose(another)
+      Mayak::OptionalFunction[T.type_parameter(:Input2), Output].new { |input| another.call(input).flat_map { |new_input| @blk.call(new_input) } }
+    end
+    alias << compose
+
+    sig {
+      type_parameters(
+        :Input,
+        :Output
+      ).params(
+        function: Mayak::Function[T.type_parameter(:Input), Mayak::Monads::Maybe[T.type_parameter(:Output)]]
+      ).returns(
+        Mayak::OptionalFunction[T.type_parameter(:Input), T.type_parameter(:Output)]
+      )
+    }
+    def self.from_function(function)
+      Mayak::OptionalFunction[T.type_parameter(:Input), T.type_parameter(:Output)].new { |input| function.call(input) }
+    end
+  end
+end

data/lib/mayak/validation_result.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module ValidationResult
+    extend T::Sig
+    extend T::Generic
+
+    include Kernel
+
+    sealed!
+    abstract!
+
+    Error = type_member(:out)
+
+    sig {
+      abstract.type_parameters(
+        :NewError
+      ).params(
+        blk: T.proc.params(arg: Error).returns(T.type_parameter(:NewError))
+      ).returns(
+        ::Mayak::ValidationResult[T.any(Error, T.type_parameter(:NewError))]
+      )
+    }
+    def map_errors(&blk)
+    end
+
+    sig { returns(T::Boolean) }
+    def valid?
+      is_a?(::Mayak::ValidationResult::Valid)
+    end
+
+    sig { returns(T::Boolean) }
+    def invalid?
+      !valid?
+    end
+
+    sig {
+      type_parameters(:A)
+        .params(blk: T.proc.returns(T.type_parameter(:A)))
+        .returns(T.any(::Mayak::ValidationResult::Invalid[Error], T.type_parameter(:A)))
+    }
+    def on_valid(&blk)
+      if is_a?(::Mayak::ValidationResult::Valid)
+        blk.call
+      else
+        self
+      end
+    end
+
+    sig { params(exceptions: T::Array[StandardError]).returns(::Mayak::ValidationResult[StandardError]) }
+    def self.from_exceptions(exceptions)
+      if exceptions.empty?
+        ::Mayak::ValidationResult::Valid[StandardError].new
+      else
+        ::Mayak::ValidationResult::Invalid[StandardError].new(errors: exceptions)
+      end
+    end
+
+    sig { params(strings: T::Array[String]).returns(::Mayak::ValidationResult[String]) }
+    def self.from_strings(strings)
+      if strings.empty?
+        ::Mayak::ValidationResult::Valid[String].new
+      else
+        ::Mayak::ValidationResult::Invalid[String].new(errors: strings)
+      end
+    end
+
+    class Valid
+      extend T::Sig
+      extend T::Generic
+
+      include ::Mayak::ValidationResult
+
+      Error = type_member
+
+      sig {
+        override.type_parameters(
+          :NewError
+        ).params(
+          blk: T.proc.params(arg: Error).returns(T.type_parameter(:NewError))
+        ).returns(
+          ::Mayak::ValidationResult[T.any(Error, T.type_parameter(:NewError))]
+        )
+      }
+      def map_errors(&blk)
+        self
+      end
+    end
+
+    class Invalid < T::Struct
+      extend T::Sig
+      extend T::Generic
+
+      include ::Mayak::ValidationResult
+
+      Error = type_member
+
+      const :errors, T::Array[Error]
+
+      sig {
+        override.type_parameters(
+          :NewError
+        ).params(
+          blk: T.proc.params(arg: Error).returns(T.type_parameter(:NewError))
+        ).returns(
+          ::Mayak::ValidationResult[T.any(Error, T.type_parameter(:NewError))]
+        )
+      }
+      def map_errors(&blk)
+        ::Mayak::ValidationResult::Invalid[T.any(Error, T.type_parameter(:NewError))].new(errors: errors.map(&blk))
+      end
+    end
+  end
+end

data/lib/mayak.rb

@@ -5,6 +5,7 @@ require 'sorbet-runtime'
 
 require_relative 'mayak/cache'
 require_relative 'mayak/function'
+require_relative 'mayak/failable_function'
 require_relative 'mayak/json'
 require_relative 'mayak/numeric'
 require_relative 'mayak/random'

data/mayak.gemspec

@@ -4,7 +4,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "mayak"
-  spec.version       = "0.0.11"
+  spec.version       = "0.0.12"
   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.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-18 00:00:00.000000000 Z
+date: 2024-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -111,6 +111,7 @@ files:
 - lib/mayak/collections/queue.rb
 - lib/mayak/decoder.rb
 - lib/mayak/encoder.rb
+- lib/mayak/failable_function.rb
 - lib/mayak/function.rb
 - lib/mayak/hash_serializable.rb
 - lib/mayak/http/README.md
@@ -128,8 +129,10 @@ files:
 - lib/mayak/monads/result.rb
 - lib/mayak/monads/try.rb
 - lib/mayak/numeric.rb
+- lib/mayak/optional_function.rb
 - lib/mayak/predicates/rule.rb
 - lib/mayak/random.rb
+- lib/mayak/validation_result.rb
 - lib/mayak/version.rb
 - lib/mayak/weak_ref.rb
 - mayak.gemspec