mayak 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb1722eed3175033b058ab2e87589e45d31fb701f402f51978758663d0ad3c82
-  data.tar.gz: 3b2aa6f45f79aa848bd017e208f4568aef6ecdc9f3f80fb18eae8b5053fee551
+  metadata.gz: 7c803fe79f01fbe1d57d090db09b47e5e8500656819f61951e120fd10860680e
+  data.tar.gz: 8dcaeaa4cbf92d629113c7faedaa1048dad5a69aaca38e82fbadd8609631be3b
 SHA512:
-  metadata.gz: 9ea0826e78b1cf81e74fae2df74d42f3842e19fa05c5b9bfcdd95955221efb8cb161bcd72dd8623e55defd8b1b1677745edea195b9bf4c5c644eadb575f47d92
-  data.tar.gz: d20145430d27b269422d1c18a81256704969535c7a9616ad92da9008a4fb3ca63a46c5d24b103473232ab5a3de513f91b455d77213a75ff06c54df93d91f4b1f
+  metadata.gz: 144fb12c3b37c4cd8f8abdcca91042178647273ee26f8abc23bf3f83373ad5e04affda9aa1a58331fc619f0c362156b57f5b6d5b66bde15bfd5b1c5b966ef042
+  data.tar.gz: e50fe76a28b4591a0ee5b3de40da4b88bff7a05303d7673e00d9873b6abd41a6d6b94d0367660d61bd2777e2d3871f399a83b9f3fbcb1ad9bbaa97b868021184

data/README.md

@@ -1,4 +1,7 @@
-# Mayak
+[gem]: https://rubygems.org/gems/mayak
+[actions]: https://github.com/dnvkv/mayak/actions
+
+# Mayak [![Gem Version](https://badge.fury.io/rb/mayak.svg)][gem] [![CI Status](https://github.com/dnvkv/mayak/actions/workflows/ci.yml/badge.svg)][actions]
 
 ### Overview
 
@@ -38,234 +41,11 @@ Mayak consists from separate classes and interfaces as well as separate modules
 
 [Documentation](./lib/mayak/http/README.md)
 
-#### 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.
+#### Lazy
 
-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.
+[Documentation](./lib/mayak/lazy/README.md)
 
-```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]
-```
+#### Miscellaneous
 
 ##### Function
 In some situations Sorbet can not infer a type of proc passed:

data/lib/mayak/codec.rb

@@ -0,0 +1,70 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Mayak
+  module Codec
+    extend T::Sig
+    extend T::Generic
+    extend T::Helpers
+
+    abstract!
+
+    Entity  = type_member
+    Protocol = type_member
+
+    sig { abstract.params(entity: Entity).returns(Protocol) }
+    def encode(entity)
+    end
+
+    sig {
+      abstract
+        .params(response: Protocol)
+        .returns(Mayak::Monads::Try[Entity])
+    }
+    def decode(response)
+    end
+
+    sig { returns(::Mayak::Encoder[Entity, Protocol]) }
+    def to_encoder
+      ::Mayak::Encoder::Implementation[Entity, Protocol].new do |entity|
+        encode(entity)
+      end
+    end
+
+    sig { returns(::Mayak::Decoder[Protocol, Entity]) }
+    def to_decoder
+      ::Mayak::Decoder::Implementation[Protocol, Entity].new do |protocol|
+        decode(protocol)
+      end
+    end
+
+    class FromPair < T::Struct
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      Entity  = type_member
+      Protocol = type_member
+
+      include ::Mayak::Codec
+
+      const :encoder, ::Mayak::Encoder[Entity, Protocol]
+      const :decoder, ::Mayak::Decoder[Protocol, Entity]
+
+
+      sig { override.params(entity: Entity).returns(Protocol) }
+      def encode(entity)
+        encoder.encode(entity)
+      end
+
+      sig {
+        override
+          .params(response: Protocol)
+          .returns(Mayak::Monads::Try[Entity])
+      }
+      def decode(response)
+        decoder.decode(response)
+      end
+    end
+  end
+end

data/lib/mayak/csv/body.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Body < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :rows, T::Array[Row[Value]]
+    end
+  end
+end

data/lib/mayak/csv/codec.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    module Codec
+      extend T::Sig
+    end
+  end
+end

data/lib/mayak/csv/column.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Column < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :name,       String
+      const :serializer, T.proc.params(value: Value).returns(String)
+    end
+  end
+end

data/lib/mayak/csv/decoder.rb

@@ -0,0 +1,154 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    module Decoder
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      abstract!
+    
+      sig {
+        abstract
+          .params(csv: T.any(String, T::Enumerable[String]))
+          .returns(Mayak::Monads::Try[T::Array[Value]])
+      }
+      def decode(csv)
+      end
+
+      sig {
+        type_parameters(:NewValue)
+          .params(blk: T.proc.params(arg: Value).returns(T.type_parameter(:NewValue)))
+          .returns(::Mayak::Csv::Decoder[T.type_parameter(:NewValue)])
+      }
+      def map(&blk)
+        ::Mayak::Csv::Decoder::FromFunction[T.type_parameter(:NewValue)].new(fn: -> (csv) do
+          decode(csv).map do |values|
+            values.map { |value| blk.call(value) }
+          end
+        end)
+      end
+
+      sig {
+        type_parameters(:NewValue)
+          .params(blk: T.proc.params(arg: Value).returns(Mayak::Monads::Try[T.type_parameter(:NewValue)]))
+          .returns(::Mayak::Csv::Decoder[T.type_parameter(:NewValue)])
+      }
+      def map_try(&blk)
+        ::Mayak::Csv::Decoder::FromFunction[T.type_parameter(:NewValue)].new(fn: -> (csv) do
+          decode(csv).flat_map do |values|
+            Mayak::Monads::Try.sequence(
+              values.map { |value| blk.call(value) }
+            )
+          end
+        end)
+      end
+
+      sig { params(separator: String).returns(Mayak::Csv::Decoder[T::Hash[String, String]]) }
+      def self.hash_decoder_strict(separator: ",")
+        HashDecoderStrict.new(separator: separator)
+      end
+
+      sig { params(separator: String).returns(Mayak::Csv::Decoder[T::Hash[String, T.nilable(String)]]) }
+      def self.hash_decoder(separator: ",")
+        HashDecoder.new(separator: separator)
+      end
+
+      class HashDecoder < T::Struct
+        extend T::Sig
+        extend T::Generic
+      
+        Value = type_member {{ fixed: T::Hash[String, T.nilable(String)] }}
+
+        const :separator, String, default: ","
+
+        include ::Mayak::Csv::Decoder
+      
+        sig {
+          override
+            .params(csv: T.any(String, T::Enumerable[String]))
+            .returns(Mayak::Monads::Try[T::Array[Value]])
+        }
+        def decode(csv)
+          csv_string = begin
+            case csv
+            when String then csv
+            else csv.to_a.join("\n")
+            end
+          end
+          Mayak::Monads::Try::Success.new(CSV.parse(csv_string, headers: :first_row, col_sep: separator).map(&:to_h))
+        end
+      end
+
+      class HashDecoderStrict < T::Struct
+        extend T::Sig
+        extend T::Generic
+      
+        Value = type_member {{ fixed: T::Hash[String, String] }}
+
+        const :separator, String, default: ","
+
+        include ::Mayak::Csv::Decoder
+      
+        sig {
+          override
+            .params(csv: T.any(String, T::Enumerable[String]))
+            .returns(Mayak::Monads::Try[T::Array[Value]])
+        }
+        def decode(csv)
+          lines = begin
+            case csv
+            when String then csv.split("\n")
+            else csv.to_a
+            end
+          end
+          header, *rows = lines
+          return Mayak::Monads::Try::Success.new([]) if rows.nil? || rows.empty?
+          return Mayak::Monads::Try::Success.new([]) if header.nil? || header.empty?
+          keys = header.split(separator)
+          parse_results = rows.map.with_index do |row, index|
+            values = row.split(separator)
+            if values.length != keys.length
+              Mayak::Monads::Try::Failure.new(
+                ::Mayak::Csv::ParseError.new(build_error_message(keys.length, row.length, index))
+              )
+            else
+              keys.zip(values).to_h
+            end
+          end
+          Mayak::Monads::Try.sequence(parse_results).map(&:to_h)
+        end
+
+        private
+
+        sig { params(keys_length: Integer, rows_length: Integer, index: Integer).returns(String) }
+        def build_error_message(keys_length, rows_length, index)
+          "Invalid number of columns on line #{index + 2}: expected #{keys_length}, found #{rows_length}"
+        end
+      end
+    
+      class FromFunction < T::Struct
+        extend T::Sig
+        extend T::Generic
+    
+        Value = type_member
+    
+        include ::Mayak::Csv::Decoder
+    
+        const :fn, T.proc.params(csv: T.any(String, T::Enumerable[String])).returns(Mayak::Monads::Try[T::Array[Value]])
+    
+        sig {
+          override
+            .params(csv: T.any(String, T::Enumerable[String]))
+            .returns(Mayak::Monads::Try[T::Array[Value]])
+        }
+        def decode(csv)
+          fn.call(csv)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/csv/document.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Document < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :header, Header[Value]
+      const :body,   Body[Value]
+
+      sig { params(separator: String).returns(String) }
+      def serialize_to_csv(separator: ",")
+        buffer = String.new
+        buffer << header.serialize_to_csv(separator: separator)
+        buffer << "\n"
+        body.rows.each do |row|
+          buffer << row.serialize_to_csv(separator: separator)
+          buffer << "\n"
+        end
+        buffer
+      end
+    end
+  end
+end

data/lib/mayak/csv/encoder.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    module Encoder
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      abstract!
+    
+      sig { abstract.params(values: T::Enumerable[Value]).returns(String) }
+      def encode(values)
+      end
+    
+      class FromFunction < T::Struct
+        extend T::Sig
+        extend T::Generic
+    
+        Value = type_member
+    
+        include ::Mayak::Csv::Encoder
+    
+        const :fn, T.proc.params(value: T::Enumerable[Value]).returns(String)
+    
+        sig { override.params(values: T::Enumerable[Value]).returns(String) }
+        def encode(values)
+          fn.call(values)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/csv/header.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Header < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :columns, T::Array[Column[Value]]
+    
+      sig {
+        params(
+          name:       String,
+          serializer: T.proc.params(value: Value).returns(String)
+        ).returns(::Mayak::Csv::Header[Value])
+      }
+      def with_column(name, &serializer)
+        new_column = ::Mayak::Csv::Column[Value].new(
+          name:       name,
+          serializer: -> (value) { serializer.call(value) }
+        )
+        Header[Value].new(columns: columns.concat([new_column]))
+      end
+    
+      sig { params(values: T::Enumerable[Value]).returns(Body[Value]) }
+      def build_body(values)
+        rows = values.map do |value|
+          Row.new(cells: columns.map { |column| [column, column.serializer.call(value)] })
+        end
+        Body.new(rows: rows)
+      end
+    
+      sig { params(values: T::Enumerable[Value]).returns(Document[Value]) }
+      def build_document(values)
+        Document[Value].new(header: self, body: build_body(values))
+      end
+
+      sig { params(separator: String).returns(String) }
+      def serialize_to_csv(separator: ",")
+        columns.map(&:name).join(separator)
+      end
+    
+      sig { params(separator: String).returns(::Mayak::Csv::Encoder[Value]) }
+      def to_encoder(separator: ",")
+        ::Mayak::Csv::Encoder::FromFunction[Value].new(
+          fn: -> (values) { build_document(values).serialize_to_csv(separator: separator) }
+        )
+      end
+    end
+  end
+end

data/lib/mayak/csv/parse_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Csv
+    class ParseError < StandardError
+    end
+  end
+end

data/lib/mayak/csv/row.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayak
+  module Csv
+    class Row < T::Struct
+      extend T::Sig
+      extend T::Generic
+    
+      Value = type_member
+    
+      const :cells, T::Array[[Column[Value], String]]
+
+      sig { params(separator: String).returns(String) }
+      def serialize_to_csv(separator: ",")
+        cells.map { |cell| cell[1] }.join(separator)
+      end
+    end
+  end
+end

data/lib/mayak/decoder.rb

@@ -9,15 +9,51 @@ module Mayak
 
     abstract!
 
-    RequestType   = type_member
-    RequestEntity = type_member
+    In  = type_member(:in)
+    Out = type_member(:out)
 
     sig {
       abstract
-        .params(response: RequestType)
-        .returns(Mayak::Monads::Try[RequestEntity])
+        .params(response: In)
+        .returns(Mayak::Monads::Try[Out])
     }
     def decode(response)
     end
+
+    sig {
+      type_parameters(:In2)
+        .params(blk: T.proc.params(arg0: Out).returns(T.type_parameter(:In2)))
+        .returns(::Mayak::Decoder[In, T.type_parameter(:In2)])
+    }
+    def map(&blk)
+      ::Mayak::Decoder::Implementation[In, T.type_parameter(:In2)].new do |entity|
+        decode(entity).map { |result| blk.call(result) }
+      end
+    end
+
+    class Implementation
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      include ::Mayak::Decoder
+
+      In = type_member
+      Out   = type_member
+
+      sig { params(function: T.proc.params(response: In).returns(::Mayak::Monads::Try[Out])).void }
+      def initialize(&function)
+        @function = T.let(function, T.proc.params(response: In).returns(::Mayak::Monads::Try[Out]))
+      end
+
+      sig {
+        override
+          .params(response: In)
+          .returns(Mayak::Monads::Try[Out])
+      }
+      def decode(response)
+        @function.call(response)
+      end
+    end
   end
 end

data/lib/mayak/encoder.rb

@@ -9,40 +9,40 @@ module Mayak
 
     abstract!
 
-    ResponseEntity = type_member
-    ResponseType   = type_member
+    In  = type_member(:in)
+    Out = type_member(:out)
 
-    sig { abstract.params(entity: ResponseEntity).returns(ResponseType) }
-    def encode(entity)
+    sig { abstract.params(input: In).returns(Out) }
+    def encode(input)
     end
 
     sig {
-      type_parameters(:NewResponse)
-        .params(blk: T.proc.params(arg0: ResponseType).returns(T.type_parameter(:NewResponse)))
-        .returns(::Mayak::Encoder[ResponseEntity, T.type_parameter(:NewResponse)])
+      type_parameters(:In2)
+        .params(blk: T.proc.params(arg0: Out).returns(T.type_parameter(:In2)))
+        .returns(::Mayak::Encoder[In, T.type_parameter(:In2)])
     }
-    def map_request(&blk)
-      ::Mayak::Encoder::FromFunction[ResponseEntity, T.type_parameter(:NewResponse)].new do |entity|
+    def map(&blk)
+      ::Mayak::Encoder::Implementation[In, T.type_parameter(:In2)].new do |entity|
         blk.call(encode(entity))
       end
     end
 
-    class FromFunction
+    class Implementation
       extend T::Sig
       extend T::Generic
       extend T::Helpers
 
       include ::Mayak::Encoder
 
-      ResponseEntity = type_member
-      ResponseType   = type_member
+      In = type_member
+      Out   = type_member
 
-      sig { params(function: T.proc.params(response: ResponseEntity).returns(ResponseType)).void }
+      sig { params(function: T.proc.params(in: In).returns(Out)).void }
       def initialize(&function)
-        @function = T.let(function, T.proc.params(response: ResponseEntity).returns(ResponseType))
+        @function = T.let(function, T.proc.params(in: In).returns(Out))
       end
 
-      sig { override.params(entity: ResponseEntity).returns(ResponseType) }
+      sig { override.params(entity: In).returns(Out) }
       def encode(entity)
         @function.call(entity)
       end

data/lib/mayak/http/decoder.rb

@@ -14,8 +14,8 @@ module Mayak
 
       include ::Mayak::Decoder
 
-      RequestType   = type_member {{ fixed: ::Mayak::Http::Request }}
-      RequestEntity = type_member
+      In  = type_member(:in) {{ fixed: ::Mayak::Http::Request }}
+      Out = type_member(:out)
 
       sig {
         type_parameters(:A)
@@ -33,13 +33,13 @@ module Mayak
 
         include ::Mayak::Http::Decoder
 
-        RequestType   = type_member {{ fixed: ::Mayak::Http::Request }}
-        RequestEntity = type_member {{ fixed: ::Mayak::Http::Request }}
+        In   = type_member(:in) {{ fixed: ::Mayak::Http::Request }}
+        Out = type_member(:out) {{ fixed: ::Mayak::Http::Request }}
 
         sig {
           override
-            .params(response: RequestType)
-            .returns(Mayak::Monads::Try[RequestEntity])
+            .params(response: In)
+            .returns(Mayak::Monads::Try[Out])
         }
         def decode(response)
           Mayak::Monads::Try::Success.new(response)
@@ -53,15 +53,15 @@ module Mayak
 
         include ::Mayak::Http::Decoder
 
-        RequestType   = type_member {{ fixed: ::Mayak::Http::Request }}
-        RequestEntity = type_member
+        In  = type_member {{ fixed: ::Mayak::Http::Request }}
+        Out = type_member
 
-        const :decoder, T.proc.params(arg: String).returns(Mayak::Monads::Try[RequestEntity])
+        const :decoder, T.proc.params(arg: String).returns(Mayak::Monads::Try[Out])
 
         sig {
           override
-            .params(response: RequestType)
-            .returns(Mayak::Monads::Try[RequestEntity])
+            .params(response: In)
+            .returns(Mayak::Monads::Try[Out])
         }
         def decode(response)
           decoder.call(response.body || "")

data/lib/mayak/http/encoder.rb

@@ -12,8 +12,8 @@ module Mayak
 
       include ::Mayak::Encoder
 
-      ResponseEntity = type_member
-      ResponseType   = type_member {{ fixed: Mayak::Http::Response }}
+      In = type_member
+      Out   = type_member {{ fixed: Mayak::Http::Response }}
 
       class IdentityEncoder
         extend T::Sig
@@ -22,36 +22,15 @@ module Mayak
 
         include ::Mayak::Http::Encoder
 
-        ResponseEntity = type_member {{ fixed: ::Mayak::Http::Response }}
-        ResponseType   = type_member {{ fixed: Mayak::Http::Response }}
+        In  = type_member {{ fixed: ::Mayak::Http::Response }}
+        Out = type_member {{ fixed: Mayak::Http::Response }}
 
-        sig { override.params(entity: ResponseEntity).returns(ResponseType) }
+        sig { override.params(entity: In).returns(Out) }
         def encode(entity)
           entity
         end
       end
 
-      class FromFunction
-        extend T::Sig
-        extend T::Generic
-        extend T::Helpers
-
-        include ::Mayak::Http::Encoder
-
-        ResponseEntity = type_member
-        ResponseType   = type_member {{ fixed: Mayak::Http::Response }}
-
-        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
-
       class FromHashSerializableJson < T::Struct
         extend T::Sig
         extend T::Generic
@@ -62,10 +41,10 @@ module Mayak
         const :default_status,  Integer
         const :default_headers, T::Hash[String, String]
 
-        ResponseEntity = type_member {{ fixed: ::Mayak::HashSerializable }}
-        ResponseType   = type_member {{ fixed: Mayak::Http::Response }}
+        In = type_member {{ fixed: ::Mayak::HashSerializable }}
+        Out   = type_member {{ fixed: Mayak::Http::Response }}
 
-        sig { override.params(entity: ResponseEntity).returns(ResponseType) }
+        sig { override.params(entity: In).returns(Out) }
         def encode(entity)
           Mayak::Http::Response.new(
             status:  default_status,

data/lib/mayak/json/encoder.rb

@@ -14,29 +14,8 @@ module Mayak
 
       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
+      In = type_member
+      Out = type_member {{ fixed: ::Mayak::Json::JsonType }}
     end
   end
 end

data/lib/mayak/lazy/README.md

@@ -0,0 +1,226 @@
+# 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]
+```

data/lib/mayak.rb

@@ -30,7 +30,6 @@ require_relative 'mayak/http/request'
 require_relative 'mayak/http/response'
 require_relative 'mayak/http/verb'
 require_relative 'mayak/http/client'
-require_relative 'mayak/http/codec'
 
 require_relative 'mayak/monads/maybe'
 require_relative 'mayak/monads/result'

data/mayak.gemspec

@@ -4,7 +4,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "mayak"
-  spec.version       = "0.1.0"
+  spec.version       = "0.2.0"
   spec.summary       = "Set of fully typed utility classes and interfaces integrated with Sorbet."
   spec.description   = spec.summary
   spec.authors       = ["Daniil Bober"]
@@ -18,6 +18,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "parlour"
   spec.add_development_dependency "tapioca"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mayak
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniil Bober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-26 00:00:00.000000000 Z
+date: 2025-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -66,20 +66,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: parlour
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: tapioca
   requirement: !ruby/object:Gem::Requirement
@@ -107,9 +93,19 @@ files:
 - lib/mayak/caching/README.md
 - lib/mayak/caching/lru_cache.rb
 - lib/mayak/caching/unbounded_cache.rb
+- lib/mayak/codec.rb
 - lib/mayak/collections/README.md
 - lib/mayak/collections/priority_queue.rb
 - lib/mayak/collections/queue.rb
+- lib/mayak/csv/body.rb
+- lib/mayak/csv/codec.rb
+- lib/mayak/csv/column.rb
+- lib/mayak/csv/decoder.rb
+- lib/mayak/csv/document.rb
+- lib/mayak/csv/encoder.rb
+- lib/mayak/csv/header.rb
+- lib/mayak/csv/parse_error.rb
+- lib/mayak/csv/row.rb
 - lib/mayak/decoder.rb
 - lib/mayak/encoder.rb
 - lib/mayak/failable_function.rb
@@ -117,7 +113,6 @@ files:
 - lib/mayak/hash_serializable.rb
 - lib/mayak/http/README.md
 - lib/mayak/http/client.rb
-- lib/mayak/http/codec.rb
 - lib/mayak/http/decoder.rb
 - lib/mayak/http/encoder.rb
 - lib/mayak/http/request.rb
@@ -126,6 +121,7 @@ files:
 - lib/mayak/json.rb
 - lib/mayak/json/encoder.rb
 - lib/mayak/lazy.rb
+- lib/mayak/lazy/README.md
 - lib/mayak/monads/README.md
 - lib/mayak/monads/maybe.rb
 - lib/mayak/monads/result.rb

data/lib/mayak/http/codec.rb

@@ -1,25 +0,0 @@
-# typed: strong
-# frozen_string_literal: true
-
-require_relative 'encoder'
-require_relative 'decoder'
-
-module Mayak
-  module Http
-    module Codec
-      extend T::Sig
-      extend T::Generic
-      extend T::Helpers
-
-      abstract!
-
-      include ::Mayak::Http::Encoder
-      include ::Mayak::Http::Decoder
-
-      ResponseEntity = type_member
-      ResponseType   = type_member {{ fixed: ::Mayak::Http::Response }}
-      RequestType    = type_member {{ fixed: ::Mayak::Http::Request }}
-      RequestEntity  = type_member
-    end
-  end
-end