mayak 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e44648baaa78861745c2730ebef1931d8b410fac5e4b3587ee25e190e25ade21
-  data.tar.gz: 6129222d4c612aadb0d2fe310fd5014491df2b83728b7dfc8884944473236dd1
+  metadata.gz: 5e0f62a1884888e93ab1375ff4a8f240b53a7886228ff9bbd6750ccb7cc68705
+  data.tar.gz: cd02858a1b245c5060f94923b1cf8bc4f490dc92768b388da369ce8ef38c4cc5
 SHA512:
-  metadata.gz: 453b3ca86ce029c06012b3505dba39726ffb693d6755e7e173388b4f010b18a8836761005c1e1f441c6ff846205375776baa1a3f036bc44d9ae948bdd76adf17
-  data.tar.gz: 94d61ec3b3b74471b68a14f077293496da87f1438d2cc4527746fee78452104ee98d0be4d4f341fc555629a0456d735637842e9d9ab62e8dd52da4dd49125052
+  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/http/codec.rb

@@ -4,7 +4,7 @@
 require_relative 'encoder'
 require_relative 'decoder'
 
-module Core
+module Mayak
   module Http
     module Codec
       extend T::Sig

data/lib/mayak/json/encoder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "json"
+
+module Mayak
+  module Json
+    module Encoder
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      abstract!
+
+      include ::Mayak::Encoder
+
+      ResponseEntity = type_member
+      ResponseType   = type_member {{ fixed: ::Mayak::Json::JsonType }}
+
+      class FromFunction
+        extend T::Sig
+        extend T::Generic
+        extend T::Helpers
+  
+        include ::Mayak::Encoder
+  
+        ResponseEntity = type_member
+        ResponseType   = type_member {{ fixed: ::Mayak::Json::JsonType }}
+  
+        sig { params(function: T.proc.params(response: ResponseEntity).returns(ResponseType)).void }
+        def initialize(&function)
+          @function = T.let(function, T.proc.params(response: ResponseEntity).returns(ResponseType))
+        end
+  
+        sig { override.params(entity: ResponseEntity).returns(ResponseType) }
+        def encode(entity)
+          @function.call(entity)
+        end
+      end
+    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.10"
+  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.10
+  version: 0.0.12
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-27 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
@@ -122,13 +123,16 @@ files:
 - lib/mayak/http/response.rb
 - lib/mayak/http/verb.rb
 - lib/mayak/json.rb
+- lib/mayak/json/encoder.rb
 - lib/mayak/monads/README.md
 - lib/mayak/monads/maybe.rb
 - 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