kind 5.2.0 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e522116072626ac76a87df9351e292f31a0f96cefa1bbc07d9e83c50198a25a8
-  data.tar.gz: 529cd2b05c6767c2553ce9fa1e157cef564e7fc0092874839c6714e0df797240
+  metadata.gz: b72fec7c07a6b3178717f30c81ecdbb6375cc1fc625c1a3fa1d39611e4dc3960
+  data.tar.gz: efec52f15083b538c99546f8d5e1c6b095c6c5c243379fc21365bae99a176e60
 SHA512:
-  metadata.gz: 206cacdc59d7288b4db022dac5c45fe95649845bb0093fbee14eb86444b145651407847b380b831c8267190f1d515b7c775810549c6ee73df61059f1d484129a
-  data.tar.gz: ff97ce3f297254fd3932b853588c6d1f47a931c16065b5961e06fc4fe219ec6672db0fe16e1d0ffef4b34d25c6e9c35cc28c655b3cc539b519e916f60162ba04
+  metadata.gz: fad78e10047e8fdd21e4c56ddcc5c8620b1ad6018f3fdfb7af097b84be23bb73c3c549cd519bec3af7980c4df89fbc5b9db2796510c518a4ad9d9b9165ef6e02
+  data.tar.gz: 3d0fa5b46405e4a766285c6e3fd95e3568c5bb1875e310941a3dd592cd99372893c7aab6cfe91a321fc6a843c966ab5fb7414e726e903021b16b92dfc03bac1e

data/.travis.sh

@@ -21,6 +21,8 @@ function run_basic_tests {
   eval "KIND_BASIC=t $bundle_cmd exec rake test TEST='test/kind/{functional/*_test,functional_test}.rb'"
   eval "KIND_BASIC=t $bundle_cmd exec rake test TEST='test/kind/either/*_test.rb'"
   eval "KIND_BASIC=t $bundle_cmd exec rake test TEST='test/kind/result/*_test.rb'"
+
+  eval "KIND_STRICT=t $bundle_cmd exec rake test TEST='test/kind/strict_disabled_test.rb'"
 }
 
 function run_with_bundler {

data/CHANGELOG.md

@@ -3,73 +3,83 @@
 This project follows [semver 2.0.0](http://semver.org/spec/v2.0.0.html) and the recommendations of [keepachangelog.com](http://keepachangelog.com/).
 
 - [Unreleased](#unreleased)
-- [5.2.0 (2021-03-17)](#520-2021-03-17)
+- [5.6.0 (2021-05-14)](#560-2021-05-14)
   - [Added](#added)
+- [5.5.0 (2021-04-05)](#550-2021-04-05)
+  - [Added](#added-1)
+- [5.4.1 (2021-03-26)](#541-2021-03-26)
+  - [Fixed](#fixed)
+- [5.4.0 (2021-03-25)](#540-2021-03-25)
+  - [Added](#added-2)
+- [5.3.0 (2021-03-23)](#530-2021-03-23)
+  - [Added](#added-3)
+- [5.2.0 (2021-03-17)](#520-2021-03-17)
+  - [Added](#added-4)
   - [Deprecated](#deprecated)
   - [Changes](#changes)
 - [5.1.0 (2021-02-23)](#510-2021-02-23)
-  - [Added](#added-1)
+  - [Added](#added-5)
   - [Deprecated](#deprecated-1)
 - [5.0.0 (2021-02-22)](#500-2021-02-22)
   - [Breaking Changes](#breaking-changes)
   - [Removed](#removed)
 - [4.1.0 (2021-02-22)](#410-2021-02-22)
-  - [Added](#added-2)
+  - [Added](#added-6)
 - [4.0.0 (2021-02-22)](#400-2021-02-22)
-  - [Added](#added-3)
+  - [Added](#added-7)
   - [Deprecated](#deprecated-2)
-  - [Fixed](#fixed)
+  - [Fixed](#fixed-1)
 - [3.1.0 (2020-07-08)](#310-2020-07-08)
-  - [Added](#added-4)
+  - [Added](#added-8)
 - [3.0.0 (2020-06-25)](#300-2020-06-25)
   - [Breaking Changes](#breaking-changes-1)
-  - [Added](#added-5)
+  - [Added](#added-9)
 - [2.3.0 (2020-06-24)](#230-2020-06-24)
-  - [Added](#added-6)
+  - [Added](#added-10)
 - [2.2.0 (2020-06-23)](#220-2020-06-23)
-  - [Added](#added-7)
+  - [Added](#added-11)
 - [2.1.0 (2020-05-12)](#210-2020-05-12)
-  - [Added](#added-8)
+  - [Added](#added-12)
   - [Breaking Changes](#breaking-changes-2)
 - [2.0.0 (2020-05-07)](#200-2020-05-07)
-  - [Added](#added-9)
+  - [Added](#added-13)
   - [Breaking Changes](#breaking-changes-3)
   - [Removed](#removed-1)
 - [1.9.0 (2020-05-06)](#190-2020-05-06)
-  - [Added](#added-10)
+  - [Added](#added-14)
 - [1.8.0 (2020-05-03)](#180-2020-05-03)
-  - [Added](#added-11)
+  - [Added](#added-15)
 - [1.7.0 (2020-05-03)](#170-2020-05-03)
-  - [Fixed](#fixed-1)
+  - [Fixed](#fixed-2)
 - [1.6.0 (2020-04-17)](#160-2020-04-17)
-  - [Added](#added-12)
+  - [Added](#added-16)
   - [Changes](#changes-1)
 - [1.5.0 (2020-04-12)](#150-2020-04-12)
-  - [Added](#added-13)
+  - [Added](#added-17)
 - [1.4.0 (2020-04-12)](#140-2020-04-12)
-  - [Added](#added-14)
+  - [Added](#added-18)
 - [1.3.0 (2020-04-12)](#130-2020-04-12)
-  - [Added](#added-15)
+  - [Added](#added-19)
 - [1.2.0 (2020-04-12)](#120-2020-04-12)
-  - [Added](#added-16)
+  - [Added](#added-20)
 - [1.1.0 (2020-04-09)](#110-2020-04-09)
-  - [Added](#added-17)
-  - [Fixed](#fixed-2)
+  - [Added](#added-21)
+  - [Fixed](#fixed-3)
 - [1.0.0 (2020-03-16)](#100-2020-03-16)
-  - [Added](#added-18)
+  - [Added](#added-22)
 - [0.6.0 (2020-01-06)](#060-2020-01-06)
-  - [Added](#added-19)
+  - [Added](#added-23)
 - [0.5.0 (2020-01-04)](#050-2020-01-04)
-  - [Added](#added-20)
+  - [Added](#added-24)
 - [0.4.0 (2020-01-03)](#040-2020-01-03)
-  - [Added](#added-21)
+  - [Added](#added-25)
 - [0.3.0 (2020-01-03)](#030-2020-01-03)
-  - [Added](#added-22)
+  - [Added](#added-26)
   - [Breaking Changes](#breaking-changes-4)
 - [0.2.0 (2020-01-02)](#020-2020-01-02)
-  - [Added](#added-23)
+  - [Added](#added-27)
 - [0.1.0 (2019-12-26)](#010-2019-12-26)
-  - [Added](#added-24)
+  - [Added](#added-28)
 
 ## Unreleased
 
@@ -81,6 +91,162 @@ This project follows [semver 2.0.0](http://semver.org/spec/v2.0.0.html) and the
 ### Fixed
 -->
 
+5.6.0 (2021-05-14)
+------------------
+
+### Added
+
+* [#57](https://github.com/serradura/kind/pull/57) - Allow the usage of `nil` to define union types.
+  ```ruby
+  (Kind::String | nil) === ''  # true
+  (Kind::String | nil) === nil # true
+
+  (Kind::String | nil) === {}  # false
+  ```
+
+[⬆️  Back to Top](#changelog-)
+
+5.5.0 (2021-04-05)
+------------------
+
+### Added
+
+* [#56](https://github.com/serradura/kind/pull/56) - Add `Kind.or_nil()`.
+  ```ruby
+  Kind.or_nil(String, 1) # nil
+
+  Kind.or_nil(String, '') # ""
+
+  # --
+
+  filled_string = ->(value) { value.is_a?(String) && !value.empty? }
+
+  Kind.or_nil(filled_string, 1)  # nil
+  Kind.or_nil(filled_string, '') # nil
+
+  Kind.or_nil(filled_string, '1') # "1"
+  ```
+
+[⬆️  Back to Top](#changelog-)
+
+5.4.1 (2021-03-26)
+------------------
+
+### Fixed
+
+* [#55](https://github.com/serradura/kind/pull/55) - Fix `Kind::Either::Left#value_or` and `Kind::Result::Failure#value_or` by allowing them to receive the value of the monad in a call using a block.
+
+[⬆️  Back to Top](#changelog-)
+
+5.4.0 (2021-03-25)
+------------------
+
+### Added
+
+* [#54](https://github.com/serradura/kind/pull/54) - Add `Kind::Functional::Steps` to allow the usage of `Step`, `Map`, `Try`, `Tee`, `Check`, `Success` and `Failure` in any kind of object.
+  ```ruby
+  # Usage in classes' instances
+
+  class BaseJob
+    def self.perform_now(input); new.perform(input); end
+
+    def perform(input); raise NotImplementedError; end
+  end
+
+  class CreateUserJob < BaseJob
+    include Kind::Functional::Steps
+
+    def perform(input)
+      validate(input) \
+      >> Step(:create) \
+      >> Step(:welcome_email)
+    end
+
+    private
+
+      def validate(input)
+        # Success() or Failure()
+      end
+
+      def create(input)
+        # Success() or Failure()
+      end
+
+      def welcome_email(email)
+        # Success() or Failure()
+      end
+  end
+
+  # Usage in modules (singleton methods)
+
+  module CreateUser
+    extend self, Kind::Functional::Steps
+
+    def perform(input)
+      Step!(:validate, input) \
+      >> Step(:create) \
+      >> Step(:welcome_email)
+    end
+
+    private
+
+      def validate(input)
+        # Success() or Failure()
+      end
+
+      def create(input)
+        # Success() or Failure()
+      end
+
+      def welcome_email(email)
+        # Success() or Failure()
+      end
+  end
+  ```
+
+[⬆️ &nbsp;Back to Top](#changelog-)
+
+5.3.0 (2021-03-23)
+------------------
+
+### Added
+
+* [#53](https://github.com/serradura/kind/pull/53) - Allow `Kind::Result#map` and `Kind::Result#map!` receive a callable as an argument.
+
+* [#53](https://github.com/serradura/kind/pull/53) - Add `|` and `>>` as an alias of `Kind::Result#map!`.
+
+* [#53](https://github.com/serradura/kind/pull/53) - Add step adapters for `Kind::Action` and `Kind::Functional::Action`. This is the list of methods: `Step`, `Map`, `Try`, `Tee`, `Check`.
+  ```ruby
+  module CreateUser
+    extend Kind::Functional::Action
+
+    def call!(input)
+      Step!(:validate, input) \
+        | Step(:create)
+    end
+
+    private
+
+    def validate(input)
+      # returns Success(valid_data) or Failure(validation)
+    end
+
+    def create(input)
+      # returns Success(user)
+    end
+  end
+  ```
+
+* [#53](https://github.com/serradura/kind/pull/53) - Add `kind/strict/disabled` to turn off all of the strict validations and optimize the runtime. Use case: As strict validation is useful in development, this mechanism could be used to optimize the runtime in production. List of methods that will be disabled:
+  * `Kind.of()`
+  * `Kind.of_class()`
+  * `Kind.of_module()`
+  * `Kind.of_module_or_class()`
+  * `Kind::<Type>[1]`
+  * `Kind::NotNil[1]`
+
+[⬆️ &nbsp;Back to Top](#changelog-)
+
 5.2.0 (2021-03-17)
 ------------------
 
@@ -254,6 +420,8 @@ This project follows [semver 2.0.0](http://semver.org/spec/v2.0.0.html) and the
   p number # 0
   ```
 
+[⬆️ &nbsp;Back to Top](#changelog-)
+
 * [#46](https://github.com/serradura/kind/pull/46) - Add `Kind::Either` (either monad). This is basically the same as the `Maybe` monad, but with `Some` called `Right` and `None` called `Left`. But this time, `Left` is also allowed to have an underlying value. This module isn't loaded by default, so you will need to require it.
   ```ruby
   require 'kind/either'

data/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <h1 align="center">🤷 kind</h1>
-  <p align="center"><i>A simple type system (at runtime) for Ruby - free of dependencies.</i></p>
+  <p align="center"><i>A development toolkit for Ruby with several small/cohesive abstractions to empower your development workflow - It's totally free of dependencies.</i></p>
 </p>
 
 <p align="center">
@@ -31,16 +31,18 @@
 
 **Motivation:**
 
-As a creator of Ruby gems, I have a common need that I have to handle in many of my projects: type checking of method arguments.
+This project was born to help me with a simple task, create a light and fast type checker (at runtime) for Ruby. The initial idea was to have something to raise an exception when a method or function (procs) received a wrong input.
 
-One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but, exposing useful abstractions around this. e.g: [Kind.\<Type\> methods](#verifying-the-kind-of-some-object), [active model validations](#kindvalidator-activemodelvalidations), [maybe monad](#kindmaybe).
+But through time it was natural the addition of more features to improve the development workflow, like monads ([`Kind::Maybe`](#kindmaybe), `Kind::Either` / `Kind::Result`),  enums (`Kind::Enum`), immutable objects (`Kind::ImmutableAttributes`), [type validation via ActiveModel::Validation](#kindvalidator-activemodelvalidations), and several abstractions to help the implementation of business logic (`Kind::Functional::Steps`, `Kind::Functional::Action`, `Kind::Action`).
+
+So, I invite you to check out these features to see how they could be useful for you. Enjoy!
 
 ## Documentation <!-- omit in toc -->
 
 Version    | Documentation
 ---------- | -------------
 unreleased | https://github.com/serradura/kind/blob/main/README.md
-5.2.0      | https://github.com/serradura/kind/blob/v5.x/README.md
+5.6.0      | https://github.com/serradura/kind/blob/v5.x/README.md
 4.1.0      | https://github.com/serradura/kind/blob/v4.x/README.md
 3.1.0      | https://github.com/serradura/kind/blob/v3.x/README.md
 2.3.0      | https://github.com/serradura/kind/blob/v2.x/README.md
@@ -120,14 +122,14 @@ unreleased | https://github.com/serradura/kind/blob/main/README.md
 
 ## Compatibility
 
-| kind           | branch  | ruby     |  activemodel   |
-| -------------- | ------- | -------- | -------------- |
-| unreleased     | main    | >= 2.1.0 | >= 3.2, <= 6.1 |
-| 5.2.0          | v5.x    | >= 2.1.0 | >= 3.2, <= 6.1 |
-| 4.1.0          | v4.x    | >= 2.2.0 | >= 3.2, <= 6.1 |
-| 3.1.0          | v3.x    | >= 2.2.0 | >= 3.2, <= 6.1 |
-| 2.3.0          | v2.x    | >= 2.2.0 | >= 3.2, <= 6.0 |
-| 1.9.0          | v1.x    | >= 2.2.0 | >= 3.2, <= 6.0 |
+| kind           | branch  | ruby               | activemodel    |
+| -------------- | ------- | ------------------ | -------------- |
+| unreleased     | main    | >= 2.1.0, <= 3.0.0 | >= 3.2, < 7.0  |
+| 5.6.0          | v5.x    | >= 2.1.0, <= 3.0.0 | >= 3.2, < 7.0  |
+| 4.1.0          | v4.x    | >= 2.2.0, <= 3.0.0 | >= 3.2, < 7.0  |
+| 3.1.0          | v3.x    | >= 2.2.0, <= 2.7   | >= 3.2, < 7.0  |
+| 2.3.0          | v2.x    | >= 2.2.0, <= 2.7   | >= 3.2, <= 6.0 |
+| 1.9.0          | v1.x    | >= 2.2.0, <= 2.7   | >= 3.2, <= 6.0 |
 
 > Note: The activemodel is an optional dependency, it is related with the [Kind::Validator](#kindvalidator-activemodelvalidations).
 

data/kind.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{A simple type system (at runtime) for Ruby.}
-  spec.description   = %q{A simple type system (at runtime) for Ruby - free of dependencies.}
+  spec.summary       = %q{A development toolkit for Ruby with several small/cohesive abstractions to empower your development workflow.}
+  spec.description   = %q{A development toolkit for Ruby with several small/cohesive abstractions (monads, enums, business logic, data validation...) to empower your development workflow - It's totally free of dependencies.}
   spec.homepage      = 'https://github.com/serradura/kind'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.1.0')

data/lib/kind/__lib__/action_steps.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kind
+  module ACTION_STEPS
+    private
+
+      def Check(mthod); ->(value) { __Check(thod, value) }; end
+      def Step(mthod); ->(value) { __Step(mthod, value) }; end
+      def Map(mthod); ->(value) { __Map(mthod, value) }; end
+      def Tee(mthod); ->(value) { __Tee(mthod, value) }; end
+      def Try(mthod, opt = Empty::HASH)
+        ->(value) { __Try(mthod, value, opt) }
+      end
+
+      def Check!(mthod, value); __Check(mthod, value); end
+      def Step!(mthod, value); __Step(mthod, value); end
+      def Map!(mthod, value); __Map(mthod, value); end
+      def Tee!(mthod, value); __Tee(mthod, value); end
+      def Try!(mthod, value, opt = Empty::HASH); __Try(mthod, value, opt); end
+
+      def __Check(mthod, value) # :nodoc:
+        __resolve_step(mthod, value) ? Success(mthod, value) : Failure(mthod, value)
+      end
+
+      def __Step(mthod, value) # :nodoc:
+        __resolve_step(mthod, value)
+      end
+
+      def __Map(mthod, value) # :nodoc:
+        Success(mthod, __resolve_step(mthod, value))
+      end
+
+      def __Tee(mthod, value) # :nodoc:
+        __resolve_step(mthod, value)
+
+        Success(mthod, value)
+      end
+
+      def __Try(mthod, value, opt = Empty::HASH) # :nodoc:
+        begin
+          Success(mthod, __resolve_step(mthod, value))
+        rescue opt.fetch(:catch, StandardError) => e
+          Failure(mthod, __map_step_exception(e))
+        end
+      end
+
+      def __resolve_step(mthod, value) # :nodoc:
+        send(mthod, value)
+      end
+
+      def __map_step_exception(value) # :nodoc:
+        value
+      end
+  end
+
+  private_constant :ACTION_STEPS
+end

data/lib/kind/__lib__/attributes.rb

@@ -8,7 +8,7 @@ module Kind
     extend self
 
     def name!(name)
-      KIND.of!(::Symbol, name)
+      STRICT.kind_of(::Symbol, name)
     end
 
     def value(kind, default, visibility = :private)

data/lib/kind/__lib__/kind.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require 'kind/__lib__/strict'
+
 module Kind
   module KIND
     extend self
 
-    def null?(value) # :nodoc:
+    def nil_or_undefined?(value) # :nodoc:
       value.nil? || Undefined == value
     end
 
@@ -14,28 +16,6 @@ module Kind
       values.empty? ? of_kind : values.all?(&of_kind)
     end
 
-    def of!(kind, value, kind_name = nil) # :nodoc:
-      return value if kind === value
-
-      error!(kind_name || kind.name, value)
-    end
-
-    def error!(kind_name, value, label = nil) # :nodoc:
-      raise Error.new(kind_name, value, label: label)
-    end
-
-    def of_class?(value) # :nodoc:
-      value.kind_of?(::Class)
-    end
-
-    def of_module?(value) # :nodoc:
-      ::Module == value || (value.kind_of?(::Module) && !of_class?(value))
-    end
-
-    def of_module_or_class!(value) # :nodoc:
-      of!(::Module, value, 'Module/Class')
-    end
-
     def respond_to!(method_name, value) # :nodoc:
       return value if value.respond_to?(method_name)
 
@@ -51,15 +31,15 @@ module Kind
     end
 
     def is?(expected, value) # :nodoc:
-      is(of_module_or_class!(expected), value)
+      is(STRICT.module_or_class(expected), value)
     end
 
     private
 
       def is(expected_kind, value) # :nodoc:
-        kind = of_module_or_class!(value)
+        kind = STRICT.module_or_class(value)
 
-        if of_class?(kind)
+        if OF.class?(kind)
           kind <= expected_kind || expected_kind == ::Class
         else
           kind == expected_kind || kind.kind_of?(expected_kind)

data/lib/kind/__lib__/of.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module OF
+    extend self
+
+    def class?(value) # :nodoc:
+      value.kind_of?(::Class)
+    end
+
+    def module?(value) # :nodoc:
+      ::Module == value || (value.kind_of?(::Module) && !class?(value))
+    end
+  end
+
+  private_constant :OF
+end

data/lib/kind/__lib__/strict.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/of'
+
+module Kind
+  module STRICT
+    extend self
+
+    def error(kind_name, value, label = nil) # :nodoc:
+      raise Error.new(kind_name, value, label: label)
+    end
+
+    def object_is_a(kind, value, label = nil) # :nodoc:
+      return value if kind === value
+
+      error(kind.name, value, label)
+    end
+
+    def kind_of(kind, value, kind_name = nil) # :nodoc:
+      return value if kind === value
+
+      error(kind_name || kind.name, value)
+    end
+
+    def module_or_class(value) # :nodoc:
+      kind_of(::Module, value, 'Module/Class')
+    end
+
+    def class!(value) # :nodoc:
+      kind_of(::Class, value)
+    end
+
+    def module!(value) # :nodoc:
+      return value if OF.module?(value)
+
+      error('Module', value)
+    end
+
+    def not_nil(value, label) # :nodoc:
+      return value unless value.nil?
+
+      label_text = label ? "#{label}: " : ''
+
+      raise Error.new("#{label_text}expected to not be nil")
+    end
+  end
+
+  private_constant :STRICT
+end

data/lib/kind/action.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'kind/basic'
+require 'kind/empty'
 require 'kind/result'
 require 'kind/immutable_attributes'
+require 'kind/__lib__/action_steps'
 
 module Kind
   module Action
@@ -20,6 +22,8 @@ module Kind
       'end'
     ].join("\n").freeze
 
+    private_constant :CALL_TMPL
+
     module ClassMethods
       include ImmutableAttributes::ClassMethods
 
@@ -71,21 +75,52 @@ module Kind
       end
     end
 
+    module StepAdapters
+      private
+
+        def Check!(mthod); __Check(mthod, Empty::HASH); end
+        def Step!(mthod); __Step(mthod, Empty::HASH); end
+        def Map!(mthod); __Map(mthod, Empty::HASH); end
+        def Tee!(_mthod); raise NotImplementedError; end
+        def Try!(mthod, opt = Empty::HASH); __Try(mthod, Empty::HASH, opt); end
+
+        def __resolve_step(method_name, value)
+          m = method(method_name)
+          m.arity > 0 ? m.call(value) : m.call
+        end
+
+        def __map_step_exception(value)
+          { exception: value }
+        end
+    end
+
+    private_constant :StepAdapters
+
     def self.included(base)
-      KIND.of!(::Class, base).extend(ClassMethods)
+      Kind.of_class(base).extend(ClassMethods)
 
+      base.send(:include, ACTION_STEPS)
+      base.send(:include, StepAdapters)
       base.send(:include, ImmutableAttributes::Reader)
     end
 
     include ImmutableAttributes::Initializer
 
+    def inspect
+      '#<%s attributes=%p nil_attributes=%p>' % [self.class.name, attributes, nil_attributes]
+    end
+
     private
 
       def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        arg1 = Empty::HASH if UNDEFINED == arg1 && UNDEFINED == arg2
+
         Result::Failure[arg1, arg2, value_must_be_a: ::Hash]
       end
 
       def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        arg1 = Empty::HASH if UNDEFINED == arg1 && UNDEFINED == arg2
+
         Result::Success[arg1, arg2, value_must_be_a: ::Hash]
       end
   end

data/lib/kind/basic.rb

@@ -35,11 +35,11 @@ module Kind
   end
 
   def of_class?(value)
-    KIND.of_class?(value)
+    OF.class?(value)
   end
 
   def of_module?(value)
-    KIND.of_module?(value)
+    OF.module?(value)
   end
 
   def respond_to?(value, *method_names)
@@ -49,15 +49,21 @@ module Kind
   end
 
   def of(kind, value, label: nil)
-    return value if kind === value
-
-    KIND.error!(kind.name, value, label)
+    STRICT.object_is_a(kind, value, label)
   end
 
   alias_method :of!, :of
 
+  def of_class(value)
+    STRICT.class!(value)
+  end
+
+  def of_module(value)
+    STRICT.module!(value)
+  end
+
   def of_module_or_class(value)
-    KIND.of_module_or_class!(value)
+    STRICT.module_or_class(value)
   end
 
   def respond_to(value, *method_names)
@@ -70,4 +76,8 @@ module Kind
   def value(kind, value, default:)
     KIND.value(kind, value, of(kind, default))
   end
+
+  def or_nil(kind, value)
+    return value if kind === value
+  end
 end

data/lib/kind/dig.rb

@@ -12,7 +12,7 @@ module Kind
       keys.reduce(data) do |memo, key|
         value = get(memo, key)
 
-        break if KIND.null?(value)
+        break if KIND.nil_or_undefined?(value)
 
         value
       end
@@ -25,7 +25,7 @@ module Kind
 
       return result unless block_given?
 
-      yield(result) unless KIND.null?(result)
+      yield(result) unless KIND.nil_or_undefined?(result)
     end
 
     def presence(*args, &block)

data/lib/kind/either/left.rb

@@ -9,7 +9,7 @@ module Kind
     def value_or(default = UNDEFINED, &block)
       Error.invalid_default_arg! if UNDEFINED == default && !block
 
-      UNDEFINED != default ? default : block.call
+      UNDEFINED != default ? default : block.call(value)
     end
 
     def map(&_)

data/lib/kind/function.rb

@@ -17,9 +17,7 @@ module Kind
     end
 
     def self.extended(base)
-      KIND.error!('Module', base) unless Kind.of_module?(base)
-
-      base.extend(base)
+      base.extend(Kind.of_module(base))
     end
 
     def kind_function!

data/lib/kind/functional.rb

@@ -11,7 +11,7 @@ module Kind
     end
 
     def self.included(base)
-      KIND.of!(::Class, base).send(:extend, ClassMethods)
+      Kind.of_class(base).send(:extend, ClassMethods)
     end
 
     module Behavior
@@ -22,7 +22,7 @@ module Kind
       end
 
       def initialize(arg = Empty::HASH)
-        hash = KIND.of!(::Hash, arg)
+        hash = STRICT.kind_of(::Hash, arg)
 
         self.class.__dependencies__.each do |name, (kind, default, _visibility)|
           value_to_assign = ATTRIBUTES.value_to_assign!(kind, default, hash, name)

data/lib/kind/functional/action.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'kind/result'
 require 'kind/functional'
+require 'kind/functional/steps'
 
 module Kind
   module Functional::Action
@@ -56,10 +56,10 @@ module Kind
           "#{CALL_TMPL % [call_tmpl_args, call_tmpl_args]}"
         )
 
-        if KIND.of_module?(self)
-          self.send(:extend, Result::Methods)
+        if Kind.of_module?(self)
+          self.send(:extend, Functional::Steps)
         else
-          self.send(:include, Result::Methods)
+          self.send(:include, Functional::Steps)
           self.send(:include, Functional::Behavior)
 
           __dependencies__.freeze
@@ -72,15 +72,13 @@ module Kind
     end
 
     def self.included(base)
-      KIND.of!(::Class, base).send(:extend, Functional::DependencyInjection)
+      Kind.of_class(base).send(:extend, Functional::DependencyInjection)
 
       base.send(:extend, Macros)
     end
 
     def self.extended(base)
-      KIND.error!('Module', base) unless Kind.of_module?(base)
-
-      base.send(:extend, base)
+      base.send(:extend, Kind.of_module(base))
       base.send(:extend, Macros)
     end
 

data/lib/kind/functional/steps.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/result'
+require 'kind/__lib__/action_steps'
+
+module Kind
+  module Functional
+    module Steps
+      def self.extended(base)
+        base.extend(Result::Methods)
+        base.extend(ACTION_STEPS)
+      end
+
+      def self.included(base)
+        base.send(:include, Result::Methods)
+        base.send(:include, ACTION_STEPS)
+      end
+    end
+  end
+end

data/lib/kind/immutable_attributes/reader.rb

@@ -28,7 +28,7 @@ module Kind
       end
 
       def with_attributes(arg)
-        hash = KIND.of!(::Hash, arg)
+        hash = STRICT.kind_of(::Hash, arg)
 
         self.class.new(@_____attrs.merge(hash))
       end

data/lib/kind/maybe.rb

@@ -14,7 +14,7 @@ module Kind
     extend self
 
     def new(value)
-      (::Exception === value || KIND.null?(value) ? None : Some)
+      (::Exception === value || KIND.nil_or_undefined?(value) ? None : Some)
         .new(value)
     end
 

data/lib/kind/maybe/none.rb

@@ -25,7 +25,7 @@ module Kind
       alias_method :and_then!, :map!
 
       def try!(method_name = UNDEFINED, *args, &block)
-        KIND.of!(::Symbol, method_name)if UNDEFINED != method_name
+        STRICT.kind_of(::Symbol, method_name)if UNDEFINED != method_name
 
         self
       end

data/lib/kind/maybe/some.rb

@@ -6,12 +6,12 @@ require 'kind/presence'
 module Kind
   module Maybe
     class Some < Monad
-      KindSymbol = ->(value) { KIND.of!(::Symbol, value) }
+      KindSymbol = ->(value) { STRICT.kind_of(::Symbol, value) }
 
       VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
 
       def self.[](value)
-        return new(value) if !KIND.null?(value)
+        return new(value) if !KIND.nil_or_undefined?(value)
 
         raise ArgumentError, VALUE_CANT_BE_NONE
       end
@@ -57,7 +57,7 @@ module Kind
           fn.call(@value)
         end
 
-        !result || KIND.null?(result) ? NONE_INSTANCE : self
+        !result || KIND.nil_or_undefined?(result) ? NONE_INSTANCE : self
       end
 
       alias_method :accept, :check
@@ -73,7 +73,7 @@ module Kind
           fn.call(@value)
         end
 
-        result || KIND.null?(result) ? NONE_INSTANCE : self
+        result || KIND.nil_or_undefined?(result) ? NONE_INSTANCE : self
       end
 
       def try!(method_name = UNDEFINED, *args, &block)
@@ -120,7 +120,7 @@ module Kind
 
         def resolve(result)
           return result if Maybe::None === result
-          return NONE_INSTANCE if KIND.null?(result)
+          return NONE_INSTANCE if KIND.nil_or_undefined?(result)
           return None.new(result) if ::Exception === result
 
           Some.new(result)

data/lib/kind/objects/basic_object.rb

@@ -3,9 +3,7 @@
 module Kind
   module BasicObject
     def [](value, label: nil)
-      return value if self === value
-
-      KIND.error!(name, value, label)
+      STRICT.object_is_a(self, value, label)
     end
 
     def or_nil(value)
@@ -33,7 +31,7 @@ module Kind
     end
 
     def or_null(value) # :nodoc:
-      KIND.null?(value) ? value : self[value]
+      KIND.nil_or_undefined?(value) ? value : self[value]
     end
 
     private

data/lib/kind/objects/not_nil.rb

@@ -3,11 +3,7 @@
 module Kind
   module NotNil
     def self.[](value, label: nil)
-      return value unless value.nil?
-
-      label_text = label ? "#{label}: " : ''
-
-      raise Error.new("#{label_text}expected to not be nil")
+      STRICT.not_nil(value, label)
     end
   end
 end

data/lib/kind/objects/object.rb

@@ -34,7 +34,7 @@ module Kind
     def initialize(kind, opt)
       name = ResolveKindName.(kind, opt)
 
-      @name = KIND.of!(::String, name)
+      @name = STRICT.kind_of(::String, name)
       @kind = KIND.respond_to!(:===, kind)
     end
 

data/lib/kind/objects/respond_to.rb

@@ -5,7 +5,7 @@ module Kind
     include Kind::BasicObject
 
     def self.[](*args)
-      args.each { |arg| KIND.of!(::Symbol, arg) }
+      args.each { |arg| STRICT.kind_of(::Symbol, arg) }
 
       new(args)
     end

data/lib/kind/objects/union_type.rb

@@ -16,7 +16,7 @@ module Kind
     end
 
     def |(kind)
-      self.class.new(@kinds + [Interface[kind]])
+      self.class.new(@kinds + [Interface[kind.nil? ? Kind::Nil : kind]])
     end
 
     def ===(value)

data/lib/kind/presence.rb

@@ -7,7 +7,7 @@ module Kind
     extend self
 
     def call(object)
-      return if KIND.null?(object)
+      return if KIND.nil_or_undefined?(object)
 
       return object.blank? ? nil : object if object.respond_to?(:blank?)
 

data/lib/kind/result/failure.rb

@@ -11,13 +11,15 @@ module Kind
     def value_or(default = UNDEFINED, &block)
       Error.invalid_default_arg! if UNDEFINED == default && !block
 
-      UNDEFINED != default ? default : block.call
+      UNDEFINED != default ? default : block.call(value)
     end
 
-    def map(&_)
+    def map(_ = UNDEFINED, &_fn)
       self
     end
 
+    alias_method :|, :map
+    alias_method :>>, :map
     alias_method :map!, :map
     alias_method :then, :map
     alias_method :then!, :map

data/lib/kind/result/monad.rb

@@ -4,18 +4,21 @@ module Kind
   class Result::Monad
     include Result::Abstract
 
+    require 'kind/empty'
     require 'kind/result/monad/wrapper'
 
     attr_reader :type, :value
 
-    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, value_must_be_a: nil) # :nodoc:
-      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : KIND.of!(::Symbol, arg1)
+    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, opt = Empty::HASH) # :nodoc:
+      value_must_be_a = opt[:value_must_be_a]
+
+      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : STRICT.kind_of(::Symbol, arg1)
 
       Error.wrong_number_of_args!(given: 0, expected: '1 or 2') if UNDEFINED == arg1
 
       value = UNDEFINED == arg2 ? arg1 : arg2
 
-      new(type, (value_must_be_a ? KIND.of!(value_must_be_a, value) : value))
+      new(type, (value_must_be_a ? STRICT.kind_of(value_must_be_a, value) : value))
     end
 
     private_class_method :new
@@ -29,10 +32,12 @@ module Kind
       raise NotImplementedError
     end
 
-    def map(&_)
+    def map(_ = UNDEFINED, &_fn)
       raise NotImplementedError
     end
 
+    alias_method :|, :map
+    alias_method :>>, :map
     alias_method :map!, :map
     alias_method :then, :map
     alias_method :then!, :map

data/lib/kind/result/success.rb

@@ -12,29 +12,42 @@ module Kind
       @value
     end
 
-    def map(&fn)
-      map!(&fn)
+    def map(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
     rescue Kind::Monad::Error => e
       raise e
     rescue StandardError => e
       Result::Failure[:exception, e]
     end
 
-    def map!(&fn)
-      monad = fn.call(@value)
-
-      return monad if Result::Monad === monad
+    alias_method :then, :map
+    alias_method :and_then, :map
 
-      raise Kind::Monad::Error.new('Kind::Success | Kind::Failure', monad)
+    def map!(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
     end
 
-    alias_method :then, :map
+    alias_method :|, :map!
+    alias_method :>>, :map!
     alias_method :then!, :map!
-    alias_method :and_then, :map
     alias_method :and_then!, :map!
 
     def inspect
       '#<%s type=%p value=%p>' % ['Kind::Success', type, value]
     end
+
+    private
+
+      def _resolve_map(callable, fn)
+        callable.respond_to?(:call) ? _map(callable) : _map(fn)
+      end
+
+      def _map(fn)
+        monad = fn.call(@value)
+
+        return monad if Result::Monad === monad
+
+        raise Kind::Monad::Error.new('Kind::Success | Kind::Failure', monad)
+      end
   end
 end

data/lib/kind/strict/disabled.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kind
+  module STRICT
+    [
+      :object_is_a, :class!, :kind_of,
+      :module_or_class, :module!, :not_nil
+    ].each { |method_name| remove_method(method_name) }
+
+    def object_is_a(_kind, value, _label = nil) # :nodoc:
+      value
+    end
+
+    def class!(value) # :nodoc:
+      value
+    end
+
+    def kind_of(_kind, value, _kind_name = nil) # :nodoc:
+      value
+    end
+
+    def module_or_class(value) # :nodoc:
+      value
+    end
+
+    def module!(value) # :nodoc:
+      value
+    end
+
+    def not_nil(value, label) # :nodoc:
+      value
+    end
+  end
+end

data/lib/kind/try.rb

@@ -9,7 +9,7 @@ module Kind
     extend self
 
     def call!(object, method_name, args = Empty::ARRAY) # :nodoc
-      return if KIND.null?(object)
+      return if KIND.nil_or_undefined?(object)
 
       resolve(object, method_name, args)
     end
@@ -21,7 +21,7 @@ module Kind
 
       return result unless block_given?
 
-      yield(result) unless KIND.null?(result)
+      yield(result) unless KIND.nil_or_undefined?(result)
     end
 
     def presence(*args, &block)

data/lib/kind/validator.rb

@@ -101,7 +101,7 @@ class KindValidator < ActiveModel::EachValidator
     def kind_is_not(expected, value)
       case expected
       when ::Class
-        return if expected == Kind.of!(::Class, value) || value < expected
+        return if expected == Kind.of_class(value) || value < expected
 
         "must be the class or a subclass of `#{expected.name}`"
       when ::Module

data/lib/kind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kind
-  VERSION = '5.2.0'
+  VERSION = '5.6.0'
 end

metadata

@@ -1,16 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-18 00:00:00.000000000 Z
+date: 2021-05-14 00:00:00.000000000 Z
 dependencies: []
-description: A simple type system (at runtime) for Ruby - free of dependencies.
+description: A development toolkit for Ruby with several small/cohesive abstractions
+  (monads, enums, business logic, data validation...) to empower your development
+  workflow - It's totally free of dependencies.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -31,8 +33,11 @@ files:
 - bin/setup
 - kind.gemspec
 - lib/kind.rb
+- lib/kind/__lib__/action_steps.rb
 - lib/kind/__lib__/attributes.rb
 - lib/kind/__lib__/kind.rb
+- lib/kind/__lib__/of.rb
+- lib/kind/__lib__/strict.rb
 - lib/kind/__lib__/undefined.rb
 - lib/kind/action.rb
 - lib/kind/active_model/validation.rb
@@ -54,6 +59,7 @@ files:
 - lib/kind/function.rb
 - lib/kind/functional.rb
 - lib/kind/functional/action.rb
+- lib/kind/functional/steps.rb
 - lib/kind/immutable_attributes.rb
 - lib/kind/immutable_attributes/initializer.rb
 - lib/kind/immutable_attributes/reader.rb
@@ -109,6 +115,7 @@ files:
 - lib/kind/result/monad.rb
 - lib/kind/result/monad/wrapper.rb
 - lib/kind/result/success.rb
+- lib/kind/strict/disabled.rb
 - lib/kind/try.rb
 - lib/kind/validator.rb
 - lib/kind/version.rb
@@ -137,5 +144,6 @@ requirements: []
 rubygems_version: 3.2.11
 signing_key: 
 specification_version: 4
-summary: A simple type system (at runtime) for Ruby.
+summary: A development toolkit for Ruby with several small/cohesive abstractions to
+  empower your development workflow.
 test_files: []