mayak 0.0.15 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8217e22d103f9b3a253973f90f330d3b69d98320919c85b28a9d05df42c9b901
-  data.tar.gz: 89e2f9a86616f036129b0c31b09d864b811067febc4b31191a6d98ef1b332774
+  metadata.gz: eb1722eed3175033b058ab2e87589e45d31fb701f402f51978758663d0ad3c82
+  data.tar.gz: 3b2aa6f45f79aa848bd017e208f4568aef6ecdc9f3f80fb18eae8b5053fee551
 SHA512:
-  metadata.gz: e44eddcb1be94600d1501ecfbac8690557c233410ebb5a470e669201a40d564aafe00ea358027fe78887b893dc3b7cc0fb1aaa6be8f02d9d75ea19ac64abed2c
-  data.tar.gz: 2238e28cfd575b50f0a2fc6fb360485fd10c2fd754c441493f394bd289f3f38a5b54f13d952fbfa8ef09b85bbed9968f8245500ade2ae405bd5b12b93862e6cf
+  metadata.gz: 9ea0826e78b1cf81e74fae2df74d42f3842e19fa05c5b9bfcdd95955221efb8cb161bcd72dd8623e55defd8b1b1677745edea195b9bf4c5c644eadb575f47d92
+  data.tar.gz: d20145430d27b269422d1c18a81256704969535c7a9616ad92da9008a4fb3ca63a46c5d24b103473232ab5a3de513f91b455d77213a75ff06c54df93d91f4b1f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Даниил Бобер
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -9,11 +9,17 @@ Mayak is a library which aims to provide abstractions for well typed programming
 In order to use the library, add the following line to your `Gemfile`:
 
 ```ruby
-gem 'mayak'
+gem "mayak"
 ```
 or install it via the following command:
 ```ruby
-gem install 'mayak'
+gem install "mayak"
+```
+
+If you are using tapioca, add following line into tapioca's `require.rb` before generating rbi's for the gem:
+
+```ruby
+require "mayak"
 ```
 
 ### Documentation
@@ -34,6 +40,233 @@ Mayak consists from separate classes and interfaces as well as separate modules
 
 #### Miscellaneous
 
+##### Lazy
+
+`Lazy` classs represents a value that evaluates only during it's access, and evaluates only once
+during the first access. Basically, `Lazy` wraps a block of code (thunk) that returns a value (`Lazy` has single type parameter of a value), and executes only when the value accessed for the first time
+and then stores it afterward.
+
+In order to build `Lazy` a type parameter of value holded should be provided as well as a block that computes a value of the type.
+Note that the block is not executed right away.
+
+```ruby
+lazy1 = ::Mayak::Lazy[Integer].new { 1 }
+
+buffer = []
+lazy2 = ::Mayak::Lazy[Integer].new do
+  buffer << 1
+  1
+end
+buffer
+#> []
+```
+
+To access the value call `#value`. If the value is not yet computed, provided block will be executed and its result will be stored. Further invokations
+of this method won't execute the block again.
+
+```ruby
+buffer = []
+lazy = ::Mayak::Lazy[Integer].new do
+  buffer << 1
+  1
+end
+buffer
+#> []
+
+# Will execute the block and return the computed value.
+lazy.value
+#> 1
+buffer
+#> [1]
+
+# Will return the memoized value, but won't call the block again
+lazy.value
+#> 1
+buffer
+#> [1]
+```
+
+`Lazy` can be used in situations, when we want to inject some dependency into some class or method, but it may not be used, and the computation or aacquisition of the dependency may be cosftul. In this cases, it's acquisitation may be wrapped in lazy.
+
+In more imperative style
+```ruby
+sig { params(env_variable: String, file_content: ::Mayak::Lazy[String], default: String).returns(String) }
+def fetch_config(env_variable, file_content, default)
+  from_environment = ENV[env_variable]
+  if env.empty?
+    file_config = ::Core::Json.parse(file_content.value).success_or({})
+    from_file = file_config["configuration"]
+    if from_file.empty?
+      default
+    else
+      from_file
+    end
+  else
+    from_environment
+  end
+end
+```
+
+Using Mayak monads:
+```ruby
+include ::Mayak::Monads::Maybe::Mixin
+
+sig { params(env_variable: String, file_content: ::Mayak::Lazy[String], default: String).returns(String) }
+def fetch_config(env_variable, file_content, default)
+  Maybe(ENV[env_variable])
+    .recover_with_maybe(::Core::Json.parse(file_content.value).to_maybe)
+    .flat_map { |json| Maybe(json["configuration"]) }
+    .value_or(default)
+end
+```
+
+This method receives name of environment variable, and file content as lazy value. The method
+tries to read the environment variable, and if it's not present and reads the file content to find the configuration.
+`Lazy` allows to incapsulate behaviour of reading from file, so it can be passed as dependency, method `#fetch_config` doesn't 
+know anything about reading from file, but because of usage of `lazy` we can postpone it's execution thus avoiding unnecessary work.
+
+`Lazy` can be transformed via methods `#map` and `#flat_map`.  
+
+Method `#map` allows to transform value inside `Lazy` without triggering executing. Note that `#map` returns
+a new instance without mutating previous `Lazy`.
+```ruby
+int_lazy = ::Mayak::Lazy[Integer].new do
+  puts("On initialize")
+  1
+end
+string_lazy = int_lazy.map do |int|
+  puts("On mapping")
+  int.to_s
+end
+int_lazy.value # 1
+#> On initialize
+
+string_lazy.value # "1"
+#> On initialize
+#> On mapping
+
+sig { params(file_content: ::Mayak::Lazy[String]).returns(::Mayak::Lazy[Maybe[String]]) }
+def file_content_config(file_content)
+  file_content.map do |file_content|
+    ::Core::Json
+      .parse(file_content.value)
+      .to_maybe
+      .flat_map { |json| Maybe(json["configuration"]) }
+  end
+end
+```
+
+Method `#flat_map` allows to chain lazy computations. It receives a block, that builds a new `Lazy` value from the value of original
+`Lazy` and returns a new instance of `Lazy`.
+
+```ruby
+sig { params(env_name: String).returns(::Mayak::Lazy[String]) }
+def lazy_env(env_name)
+  ::Mayak::Lazy[String].new { ENV[env_name] }
+end
+
+env_variable_name = ::Mayak::Lazy[String].new { "VARIABLE" }
+env_variable = env_variable_name.flat_map { |env_name| lazy_env(env_name) }
+```
+
+This may be useful when want to perform a lazy computation based on result of some other lazy computation without enforcing the evaluation.
+
+For example we have a file that contains list of file names. We can build a lazy computation that read all lines from this code.
+```ruby
+sig { params(file_name: String).returns(::Mayak::Lazy[T::Array[String]]) }
+def read_file_lines(file_name)
+  ::Mayak::Lazy[T::Array[String]].new { File.read(file_name).split }
+end
+```
+
+Let's we want to read all filenames from the root file, and then read the first file lazily. In this cases, the lazy computation can be chained via `#flat_map`:
+
+```ruby
+sig { params(file_name: String).returns(::Mayak::Lazy[T::Array[String]]) }
+def read_first_file(file_name)
+  read_file_lines(file_name).flat_map do |file_names|
+    Maybe(file_names.first)
+      .filter(&:empty?)
+      .map { |file| read_file_lines(file) }
+      .value_or(::Mayak::Lazy[T::Array[String]].new { [] })
+  end
+end
+```
+
+In order to combine two lazies of different types into a single one, method `#combine` can be used.
+This method receives another lazy (it can be lazy of different type), and a block
+and returns a lazy containing result of applying passed blocked to values calculated by lazies.
+
+```ruby
+class ConfigFiles < T::Struct
+  const :database_config_file, ::File
+  const :server_config_file,   ::File
+end
+
+sig { returns(::Mayak::Lazy[File]) }
+def database_config_file
+  ::Mayak::Lazy[File].new { File.new(DATABASE_CONFIG_FILE_NAME, "r") }
+end
+
+sig { returns(::Mayak::Lazy[File]) }
+def server_config_file
+  ::Mayak::Lazy[File].new { File.new(SERVER_CONFIG_FILE_NAME, "r") }
+end
+
+sig { returns(::Mayak::Lazy[ConfigFiles]) }
+def config_files
+  database_config_file.combine(server_config_file) do |db_file, server_file|
+    ConfigFiles.new(
+      database_config_file: database_config_file,
+      server_config_file: server_file
+    )
+  end
+end
+```
+
+The same behaviour can be achieved with a method `.combine_two`:
+
+```ruby
+sig { returns(::Mayak::Lazy[ConfigFiles]) }
+def config_files
+  ::Mayak::Lazy.combine_two(database_config_file, server_config_file) do |db_file, server_file|
+    ConfigFiles.new(
+      database_config_file: database_config_file,
+      server_config_file: server_file
+    )
+  end
+end
+```
+
+There are also methods `.combine_three`, `.combine_four` upto `.combine_sevel` to combine multiple lazies of diffent types.
+
+If you need to combined multiple lazies containing the same value, you can use `.combine_many`. It works
+as `Array#reduce`: receives an array of lazies containing the same type, initial value of result type, and a block
+receiving accumulator value of result type, and value of next lazy.
+
+```ruby
+sig { returns(::Mayak::Lazy[Integer]) }
+def lazy
+  ::Mayak::Lazy.combine_many(
+    [::Mayak::Lazy[Integer].new(1), ::Mayak::Lazy[Integer].new(2), ::Mayak::Lazy[Integer].new(3)],
+    0
+  ) { |acc, value| acc + value }
+end
+
+lazy.value # 10
+```
+
+If you need to transform array of lazies of some value into lazy of array of the value, you can use `.sequence` method.
+
+```ruby
+sig { returns(::Mayak::Lazy[T::Array[Integer]]) }
+def lazy
+  ::Mayak::Lazy.sequence([::Mayak::Lazy[Integer].new(1), ::Mayak::Lazy[Integer].new(2), ::Mayak::Lazy[Integer].new(3)])
+end
+
+lazy.value # [1, 2, 3]
+```
+
 ##### Function
 In some situations Sorbet can not infer a type of proc passed:
 

data/lib/mayak/lazy.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "json"
+
+module Mayak
+  class Lazy
+    extend T::Sig
+    extend T::Generic
+
+    Value = type_member
+
+    sig { params(blk: T.proc.returns(Value)).void }
+    def initialize(&blk)
+      @thunk = T.let(blk, T.proc.returns(Value))
+      @value = T.let(nil, T.nilable(Value))
+      @forced = T.let(false, T::Boolean)
+    end
+
+    sig { returns(Value) }
+    def value
+      if @forced
+        T.must(@value)
+      else
+        @forced = true
+        @value = @thunk.call
+        @value
+      end
+    end
+
+    sig {
+      type_parameters(
+        :NewValue
+      ).params(
+        blk: T.proc.params(arg0: Value).returns(T.type_parameter(:NewValue))
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:NewValue)]
+      )
+    }
+    def map(&blk)
+      ::Mayak::Lazy.new { blk.call(value) }
+    end
+
+    sig {
+      type_parameters(
+        :NewValue
+      ).params(
+        blk: T.proc.params(arg0: Value).returns(::Mayak::Lazy[T.type_parameter(:NewValue)])
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:NewValue)]
+      )
+    }
+    def flat_map(&blk)
+      ::Mayak::Lazy.new { blk.call(value).value }
+    end
+
+    sig {
+      type_parameters(
+        :AnotherValue,
+        :NewValue
+      ).params(
+        another: ::Mayak::Lazy[T.type_parameter(:AnotherValue)],
+        blk:     T.proc.params(arg0: Value, arg1: T.type_parameter(:AnotherValue)).returns(T.type_parameter(:NewValue))
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:NewValue)]
+      )
+    }
+    def combine(another, &blk)
+      ::Mayak::Lazy[T.type_parameter(:NewValue)].new do
+        blk.call(value, another.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :Value
+      ).params(
+        lazies: T::Array[::Mayak::Lazy[T.type_parameter(:Value)]]
+      ).returns(
+        ::Mayak::Lazy[T::Array[T.type_parameter(:Value)]]
+      )
+    }
+    def self.sequence(lazies)
+      ::Mayak::Lazy[T::Array[T.type_parameter(:Value)]].new { lazies.map(&:value) }
+    end
+
+    sig {
+      type_parameters(
+        :FirstValue,
+        :SecondValue,
+        :ResultValue
+      ).params(
+        first: ::Mayak::Lazy[T.type_parameter(:FirstValue)],
+        second: ::Mayak::Lazy[T.type_parameter(:SecondValue)],
+        blk: T.proc.params(
+          arg0: T.type_parameter(:FirstValue),
+          arg1: T.type_parameter(:SecondValue)
+        ).returns(
+          T.type_parameter(:ResultValue)
+        )
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:ResultValue)]
+      )
+    }
+    def self.combine_two(first, second, &blk)
+      ::Mayak::Lazy[T.type_parameter(:ResultValue)].new do
+        blk.call(first.value, second.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :FirstValue,
+        :SecondValue,
+        :ThirdValue,
+        :ResultValue
+      ).params(
+        first: ::Mayak::Lazy[T.type_parameter(:FirstValue)],
+        second: ::Mayak::Lazy[T.type_parameter(:SecondValue)],
+        third: ::Mayak::Lazy[T.type_parameter(:ThirdValue)],
+        blk: T.proc.params(
+          arg0: T.type_parameter(:FirstValue),
+          arg1: T.type_parameter(:SecondValue),
+          arg2: T.type_parameter(:ThirdValue)
+        ).returns(
+          T.type_parameter(:ResultValue)
+        )
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:ResultValue)]
+      )
+    }
+    def self.combine_three(first, second, third, &blk)
+      ::Mayak::Lazy[T.type_parameter(:ResultValue)].new do
+        blk.call(first.value, second.value, third.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :FirstValue,
+        :SecondValue,
+        :ThirdValue,
+        :FourthValue,
+        :ResultValue
+      ).params(
+        first: ::Mayak::Lazy[T.type_parameter(:FirstValue)],
+        second: ::Mayak::Lazy[T.type_parameter(:SecondValue)],
+        third: ::Mayak::Lazy[T.type_parameter(:ThirdValue)],
+        fourth: ::Mayak::Lazy[T.type_parameter(:FourthValue)],
+        blk: T.proc.params(
+          arg0: T.type_parameter(:FirstValue),
+          arg1: T.type_parameter(:SecondValue),
+          arg2: T.type_parameter(:ThirdValue),
+          arg3: T.type_parameter(:FourthValue)
+        ).returns(
+          T.type_parameter(:ResultValue)
+        )
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:ResultValue)]
+      )
+    }
+    def self.combine_four(first, second, third, fourth, &blk)
+      ::Mayak::Lazy[T.type_parameter(:ResultValue)].new do
+        blk.call(first.value, second.value, third.value, fourth.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :FirstValue,
+        :SecondValue,
+        :ThirdValue,
+        :FourthValue,
+        :FifthValue,
+        :ResultValue
+      ).params(
+        first: ::Mayak::Lazy[T.type_parameter(:FirstValue)],
+        second: ::Mayak::Lazy[T.type_parameter(:SecondValue)],
+        third: ::Mayak::Lazy[T.type_parameter(:ThirdValue)],
+        fourth: ::Mayak::Lazy[T.type_parameter(:FourthValue)],
+        fifth: ::Mayak::Lazy[T.type_parameter(:FifthValue)],
+        blk: T.proc.params(
+          arg0: T.type_parameter(:FirstValue),
+          arg1: T.type_parameter(:SecondValue),
+          arg2: T.type_parameter(:ThirdValue),
+          arg3: T.type_parameter(:FourthValue),
+          arg4: T.type_parameter(:FifthValue)
+        ).returns(
+          T.type_parameter(:ResultValue)
+        )
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:ResultValue)]
+      )
+    }
+    def self.combine_five(first, second, third, fourth, fifth, &blk)
+      ::Mayak::Lazy[T.type_parameter(:ResultValue)].new do
+        blk.call(first.value, second.value, third.value, fourth.value, fifth.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :FirstValue,
+        :SecondValue,
+        :ThirdValue,
+        :FourthValue,
+        :FifthValue,
+        :SixthValue,
+        :ResultValue
+      ).params(
+        first: ::Mayak::Lazy[T.type_parameter(:FirstValue)],
+        second: ::Mayak::Lazy[T.type_parameter(:SecondValue)],
+        third: ::Mayak::Lazy[T.type_parameter(:ThirdValue)],
+        fourth: ::Mayak::Lazy[T.type_parameter(:FourthValue)],
+        fifth: ::Mayak::Lazy[T.type_parameter(:FifthValue)],
+        sixth: ::Mayak::Lazy[T.type_parameter(:SixthValue)],
+        blk: T.proc.params(
+          arg0: T.type_parameter(:FirstValue),
+          arg1: T.type_parameter(:SecondValue),
+          arg2: T.type_parameter(:ThirdValue),
+          arg3: T.type_parameter(:FourthValue),
+          arg4: T.type_parameter(:FifthValue),
+          arg5: T.type_parameter(:SixthValue)
+        ).returns(
+          T.type_parameter(:ResultValue)
+        )
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:ResultValue)]
+      )
+    }
+    def self.combine_six(first, second, third, fourth, fifth, sixth, &blk)
+      ::Mayak::Lazy[T.type_parameter(:ResultValue)].new do
+        blk.call(first.value, second.value, third.value, fourth.value, fifth.value, sixth.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :FirstValue,
+        :SecondValue,
+        :ThirdValue,
+        :FourthValue,
+        :FifthValue,
+        :SixthValue,
+        :SeventhValue,
+        :ResultValue
+      ).params(
+        first:   ::Mayak::Lazy[T.type_parameter(:FirstValue)],
+        second:  ::Mayak::Lazy[T.type_parameter(:SecondValue)],
+        third:   ::Mayak::Lazy[T.type_parameter(:ThirdValue)],
+        fourth:  ::Mayak::Lazy[T.type_parameter(:FourthValue)],
+        fifth:   ::Mayak::Lazy[T.type_parameter(:FifthValue)],
+        sixth:   ::Mayak::Lazy[T.type_parameter(:SixthValue)],
+        seventh: ::Mayak::Lazy[T.type_parameter(:SeventhValue)],
+        blk: T.proc.params(
+          arg0: T.type_parameter(:FirstValue),
+          arg1: T.type_parameter(:SecondValue),
+          arg2: T.type_parameter(:ThirdValue),
+          arg3: T.type_parameter(:FourthValue),
+          arg4: T.type_parameter(:FifthValue),
+          arg5: T.type_parameter(:SixthValue),
+          arg6: T.type_parameter(:SeventhValue),
+        ).returns(
+          T.type_parameter(:ResultValue)
+        )
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:ResultValue)]
+      )
+    }
+    def self.combine_seven(first, second, third, fourth, fifth, sixth, seventh, &blk)
+      ::Mayak::Lazy[T.type_parameter(:ResultValue)].new do
+        blk.call(first.value, second.value, third.value, fourth.value, fifth.value, sixth.value, seventh.value)
+      end
+    end
+
+    sig {
+      type_parameters(
+        :Value,
+        :Result
+      ).params(
+        lazies:  T::Array[::Mayak::Lazy[T.type_parameter(:Value)]],
+        initial: T.type_parameter(:Result),
+        blk: T.proc.params(arg0: T.type_parameter(:Result), arg1: T.type_parameter(:Value)).returns(T.type_parameter(:Result))
+      ).returns(
+        ::Mayak::Lazy[T.type_parameter(:Result)]
+      )
+    }
+    def self.combine_many(lazies, initial, &blk)
+      ::Mayak::Lazy[T.type_parameter(:Result)].new do
+        lazies.reduce(initial) { |acc, element| blk.call(acc, element.value) }
+      end
+    end
+
+    sig {
+      type_parameters(
+        :Value
+      ).params(
+        lazies:  T::Array[::Mayak::Lazy[T.type_parameter(:Value)]]
+      ).returns(
+        ::Mayak::Lazy[T::Array[T.type_parameter(:Value)]]
+      )
+    }
+    def self.sequence(lazies)
+      combine_many(lazies, []) { |acc, element| acc.concat([element]) }
+    end
+  end
+end

data/lib/mayak/validations/rule.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Validations
+    class Rule
+      extend T::Sig
+      extend T::Helpers
+      extend T::Generic
+    
+      Value = type_member
+      Error = type_member
+    
+      sig {
+        params(
+          blk: T.proc.params(arg0: Value).returns(::Mayak::ValidationResult[Error])
+        ).void
+      }
+      def initialize(&blk)
+        @blk = T.let(@blk, T.proc.params(arg0: Value).returns(::Mayak::ValidationResult[Error]))
+      end
+    
+      sig { params(value: Value).returns(::Mayak::ValidationResult[Error]) }
+      def check(value)
+        @blk.call(value)
+      end
+    
+      sig {
+        type_parameters(:NewError)
+          .params(blk: T.proc.params(arg0: Value).returns(T.type_parameter(:NewError)))
+          .returns(Rule[Value, T.type_parameter(:NewError)])
+      }
+      def error_from_value(&blk)
+        Rule[Value, T.type_parameter(:NewError)].new do |checked|
+          result = check(checked)
+    
+          case result
+          when ::Mayak::ValidationResult::Valid
+            ::Mayak::ValidationResult::Valid[T.type_parameter(:NewError)].new
+          when ::Mayak::ValidationResult::Invalid
+            ::Mayak::ValidationResult::Invalid[T.type_parameter(:NewError)].new(errors: [blk.call(checked)])
+          else
+            T.absurd(result)
+          end
+        end
+      end
+    
+      sig {
+        type_parameters(:NewError)
+          .params(new_error: T.type_parameter(:NewError))
+          .returns(Rule[Value, T.type_parameter(:NewError)])
+      }
+      def error(new_error)
+        error_from_value { |_| new_error }
+      end
+    
+      sig {
+        params(another: Rule[Value, Error]).returns(Rule[Value, Error])
+      }
+      def any(another)
+        Rule[Value, Error].new do |checked|
+          first_result = check(checked)
+          case first_result
+          when ::Mayak::ValidationResult::Valid
+            another.check(checked)
+          when ::Mayak::ValidationResult::Invalid
+            first_result
+          else
+            T.absurd(first_result)
+          end
+        end
+      end
+    
+      alias | any
+    
+      sig {
+        params(another: Rule[Value, Error]).returns(Rule[Value, Error])
+      }
+      def both(another)
+        Rule[Value, Error].new do |checked|
+          first_result = check(checked)
+          case first_result
+          when ::Mayak::ValidationResult::Valid
+            another.check(checked)
+          when ::Mayak::ValidationResult::Invalid
+            second_result = another.check(checked)
+            case second_result
+            when ::Mayak::ValidationResult::Valid
+              first_result
+            when ::Mayak::ValidationResult::Invalid
+              ::Mayak::ValidationResult::Invalid.new(errors: first_result.errors + second_result.errors)
+            else
+              T.absurd(first_result)
+            end
+          else
+            T.absurd(first_result)
+          end
+        end
+      end
+    
+      alias & both
+    
+      sig { params(key: Symbol).returns(Rule[Value, [Symbol, Error]]) }
+      def with_key(key)
+        Rule[Value, [Symbol, Error]].new do |checked|
+          result = check(checked)
+          case result
+          when ::Mayak::ValidationResult::Valid
+            ::Mayak::ValidationResult::Valid[[Symbol, Error]].new
+          when ::Mayak::ValidationResult::Invalid
+            ::Mayak::ValidationResult::Invalid[[Symbol, Error]].new(
+              errors: result.errors.map { |error| [key, error] }
+            )
+          else
+            T.absurd(result)
+          end
+        end
+      end
+    
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.greater_than(value)
+        Rule[T.any(Float, Integer), String].new do |checked|
+          if checked > value
+            ::Mayak::ValidationResult::Valid.new
+          else
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should be greater than the #{value}"]
+            )
+          end
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.less_than(value)
+        Rule[T.any(Float, Integer), String].new do |checked|
+          if checked < value
+            ::Mayak::ValidationResult::Valid.new
+          else
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should be less than the #{value}"]
+            )
+          end
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.equal_to(value)
+        Rule[T.any(Float, Integer), String].new do |checked|
+          if checked == value
+            ::Mayak::ValidationResult::Valid.new
+          else
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should equal to #{value}"]
+            )
+          end
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.greater_than_or_equal_to(value)
+        (greater_than(value) | equal_to(value)).error_from_value do |checked|
+          "Value #{checked} should greater than or equal to #{value}"
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.less_than_or_equal_to(value)
+        (less_than(value) | equal_to(value)).error_from_value do |checked|
+          "Value #{checked} should less than or equal to #{value}"
+        end
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.positive(value)
+        greater_than(0)
+      end
+    
+      sig {
+        params(
+          value: T.any(Float, Integer)
+        ).returns(Rule[T.any(Float, Integer), String])
+      }
+      def self.negative(value)
+        less_than(0)
+      end
+    
+      sig {
+        returns(Rule[T.any(String, T::Array[T.anything], T::Hash[T.anything, T.anything], String), String])
+      }
+      def self.not_empty
+        Rule[T.any(String, Array, Hash, String), String].new do |checked|
+          if checked.empty?
+            ::Mayak::ValidationResult::Invalid.new(
+              errors: ["Value #{checked} should not be empty equal"]
+            )
+          else
+            ::Mayak::ValidationResult::Valid.new
+          end
+        end
+      end
+    
+      sig {
+        type_parameters(:Value, :Error)
+          .params(rule: Rule[T.type_parameter(:Value), T.type_parameter(:Error)])
+          .returns(Rule[T.nilable(T.type_parameter(:Value)), T.type_parameter(:Error)])
+      }
+      def self.not_nil(rule)
+        Rule[T.nilable(T.type_parameter(:Value)), T.type_parameter(:Error)].new do |checked|
+          case checked
+          when NilClass
+            ::Mayak::ValidationResult::Invalid.new(errors: ["Should not be nil"])
+          else
+            rule.check(checked)
+          end
+        end
+      end
+    
+      sig {
+        type_parameters(:Value, :Error)
+          .params(rule: Rule[T.type_parameter(:Value), [Symbol, T.type_parameter(:Error)]])
+          .returns(Rule[T.type_parameter(:Value), T::Hash[Symbol, T.type_parameter(:Error)]])
+      }
+      def self.with_keys_aggregated(rule)
+        Rule[T.type_parameter(:Value), T::Hash[Symbol, T.type_parameter(:Error)]].new do |checked|
+          result = rule.check(checked)
+          case result
+          when ::Mayak::ValidationResult::Valid
+            ::Mayak::ValidationResult::Valid[T::Hash[Symbol, T.type_parameter(:Error)]].new
+          when ::Mayak::ValidationResult::Invalid
+            accumulated = result.errors.reduce({}) do |acc, tuple|
+              key, error = tuple
+              if acc.key?(key)
+                acc[key] << error
+              else
+                acc[key] = [error]
+              end
+            end
+            ::Mayak::ValidationResult::Invalid[T::Hash[Symbol, T.type_parameter(:Error)]].new(
+              accumulated
+            )
+          else
+            T.absurd(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mayak/validations/validation.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Validations
+    class Contract
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+      Error = type_member
+    
+      sig { returns(T::Set[Rule[Value, [Symbol, Error]]]) }
+      attr_reader :rule_set
+    
+      sig { params(rule_set: T::Set[Rule[Value, [Symbol, Error]]]).void }
+      def initialize(rule_set = Set.new)
+        @rule_set = T.let(rule_set, T::Set[Rule[Value, [Symbol, Error]]])
+      end
+    
+      sig {
+        type_parameters(:MappedValue)
+          .params(
+            rule: Rule[T.type_parameter(:MappedValue), Error],
+            key:  Symbol,
+            blk:  T.proc.params(arg0: Value).returns(T.type_parameter(:MappedValue))
+          ).returns(Contract[Value, Error])
+      }
+      def validate(rule, key:, &blk)
+        rule = Rule[Value, Error].new do |checked|
+          rule.check(blk.call(checked))
+        end
+        Contract.new(rule_set.add(rule.with_key(key)))
+      end
+    
+      sig { params(value: Value).returns(::Mayak::ValidationResult[T::Hash[Symbol, Error]]) }
+      def check(value)
+        initial = T.let(
+          ::Mayak::ValidationResult::Valid[T::Hash[Symbol, Error]].new,
+          ::Mayak::ValidationResult[T::Hash[Symbol, Error]]
+        )
+        rule_set.reduce(initial) do |aggreated_result, rule|
+          current_result = Rule.with_keys_aggregated(rule).check(value)
+          case aggreated_result
+          when ::Mayak::ValidationResult::Valid
+            current_result
+          when ::Mayak::ValidationResult::Invalid
+            case current_result
+            when ::Mayak::ValidationResult::Valid
+              aggreated_result
+            when ::Mayak::ValidationResult::Invalid
+              ::Mayak::ValidationResult::Invalid[T::Hash[Symbol, Error]].new(errors: [ ])
+            else
+              T.absurd(current_result)
+            end
+          else
+            T.absurd(aggreated_result)
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/mayak/version.rb

@@ -2,5 +2,5 @@
 # typed: strict
 
 module Mayak
-  VERSION = T.let("0.0.1", String)
+  VERSION = T.let("0.1.0", String)
 end

data/lib/mayak.rb

@@ -16,6 +16,7 @@ require_relative 'mayak/weak_ref'
 require_relative 'mayak/decoder'
 require_relative 'mayak/encoder'
 require_relative 'mayak/hash_serializable'
+require_relative 'mayak/lazy'
 
 require_relative 'mayak/caching/unbounded_cache'
 require_relative 'mayak/caching/lru_cache'

data/mayak.gemspec

@@ -4,7 +4,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "mayak"
-  spec.version       = "0.0.15"
+  spec.version       = "0.1.0"
   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.15
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-21 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -100,6 +100,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - lib/mayak.rb
 - lib/mayak/cache.rb
@@ -124,6 +125,7 @@ files:
 - lib/mayak/http/verb.rb
 - lib/mayak/json.rb
 - lib/mayak/json/encoder.rb
+- lib/mayak/lazy.rb
 - lib/mayak/monads/README.md
 - lib/mayak/monads/maybe.rb
 - lib/mayak/monads/result.rb
@@ -133,6 +135,8 @@ files:
 - lib/mayak/predicates/rule.rb
 - lib/mayak/random.rb
 - lib/mayak/validation_result.rb
+- lib/mayak/validations/rule.rb
+- lib/mayak/validations/validation.rb
 - lib/mayak/version.rb
 - lib/mayak/weak_ref.rb
 - mayak.gemspec