kind 1.7.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 273fcdcef40d8b61e552bb440f93a7b83adfd29621e1809201a66117babf9974
-  data.tar.gz: 84dac931b67ccc4ee895a8c2a4c3326ccfe0faf0540df09ba9fbcbfbe5034edc
+  metadata.gz: 3bb8430c79ca97835ebdf6604e0c5afc4301f912db778e5f930fb9e699ae08c1
+  data.tar.gz: 0557c3df900513e5ec7d45fec79fdf7502f0cb06a8e1538ff935e0228ef11136
 SHA512:
-  metadata.gz: b3d702df70066307c7dac3058c41dab688de46c606d57455194d77570823d051dab5fd43b5c87c870dee58b9cef41a9e93a7d9d4639fe39489cc4b0e2d93d4bf
-  data.tar.gz: 4c02cd4e43a0407167f4284c6972feed925380a0d71a8c5dedcb474a24f458954175a929dac9d5b4509520cfea663e45692dba67269712bc6e8d83e53b80a8aa
+  metadata.gz: 0ad03f0d27484914f45607d9e1fd7cfdaf8000d700e31f069b274b5f977f42a8736a3d03d0cba1f3d06679f0f5a05b56d7c3b4acfd2a90cce20e524de6f9154a
+  data.tar.gz: 6f8e54590261939a43a52895921d80fb693a0e16361d011f53a80f1d7269aaade1e8871ae44374586ec488c026a02fced9057fdfcb300c532bd3a018498e954a

data/.travis.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+bundle exec rake test
+
+ruby_v=$(ruby -v)
+
+ACTIVEMODEL_VERSION='3.2' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='4.0' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='4.1' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='4.2' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='5.0' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='5.1' bundle update && bundle exec rake test
+
+if [[ ! $ruby_v =~ '2.2.0' ]]; then
+  ACTIVEMODEL_VERSION='5.2' bundle update && bundle exec rake test
+fi
+
+if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]; then
+  ACTIVEMODEL_VERSION='6.0' bundle update && bundle exec rake test
+fi

data/.travis.yml

@@ -1,6 +1,8 @@
 ---
 language: ruby
 
+sudo: false
+
 cache: bundler
 
 rvm:
@@ -22,7 +24,7 @@ before_script:
   - chmod +x ./cc-test-reporter
   - "./cc-test-reporter before-build"
 
-script: bundle exec rake test
+script: "./.travis.sh"
 
 after_success:
   - "./cc-test-reporter after-build -t simplecov"

data/Gemfile

@@ -1,8 +1,33 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-# Specify your gem's dependencies in kind.gemspec
-gemspec
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+activemodel_version = ENV['ACTIVEMODEL_VERSION']
+
+activemodel = case activemodel_version
+              when '3.2' then '3.2.22'
+              when '4.0' then '4.0.13'
+              when '4.1' then '4.1.16'
+              when '4.2' then '4.2.11'
+              when '5.0' then '5.0.7'
+              when '5.1' then '5.1.7'
+              when '5.2' then '5.2.4'
+              when '6.0' then '6.0.0'
+              end
+
+group :test do
+  if activemodel_version
+    gem 'activesupport', activemodel, require: false
+    gem 'activemodel', activemodel, require: false
+    gem 'minitest', activemodel_version < '4.1' ? '~> 4.2' : '~> 5.0'
+  else
+    gem 'minitest', '~> 5.0'
+  end
 
-gem "rake", "~> 12.0"
-gem "minitest", "~> 5.0"
-gem "simplecov", "~> 0.17.1"
+  gem 'simplecov', require: false
+end
+
+gem 'rake', '~> 13.0'
+
+# Specify your gem's dependencies in type_validator.gemspec
+gemspec

data/README.md

@@ -6,36 +6,49 @@
 
 # Kind <!-- omit in toc -->
 
-Basic type system for Ruby.
+A simple type system (at runtime) for Ruby - free of dependencies.
 
 **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.
 
-One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but using a bunch of basic abstractions. So, after reading this README and realizing that you need something more robust, I recommend you check out the [dry-types gem](https://dry-rb.org/gems/dry-types).
+One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but, exposing useful abstractions to do it. e.g: [Kind.of.\<Type\> methods](#verifying-the-kind-of-some-object), [active model validations](#kindvalidator-activemodelvalidations), [maybe monad](#kindmaybe).
 
 ## Table of Contents <!-- omit in toc -->
 - [Required Ruby version](#required-ruby-version)
 - [Installation](#installation)
 - [Usage](#usage)
-  - [Verifying the kind of some object](#verifying-the-kind-of-some-object)
-  - [Verifying the kind of some class/module](#verifying-the-kind-of-some-classmodule)
+  - [Kind.of.\<Type\>() - Verifying the kind of some object](#kindoftype---verifying-the-kind-of-some-object)
+    - [Method aliases to perform a strict validation](#method-aliases-to-perform-a-strict-validation)
+  - [Kind.of.\<Type\>.or_nil()](#kindoftypeor_nil)
+  - [Kind.of.\<Type\>.instance?()](#kindoftypeinstance)
+  - [Kind.is.\<Type\>() - Verifying if some class/module is the expected kind.](#kindistype---verifying-if-some-classmodule-is-the-expected-kind)
   - [How to create a new type checker?](#how-to-create-a-new-type-checker)
     - [Creating/Verifiyng type checkers dynamically](#creatingverifiyng-type-checkers-dynamically)
-    - [Registering new (custom) type checkers](#registering-new-custom-type-checkers)
+    - [Registering new (custom) type checker](#registering-new-custom-type-checker)
       - [What happens if a custom type checker has a namespace?](#what-happens-if-a-custom-type-checker-has-a-namespace)
 - [Type checkers](#type-checkers)
   - [Classes' type checkers](#classes-type-checkers)
   - [Modules' type checkers](#modules-type-checkers)
   - [Specials' type checkers](#specials-type-checkers)
+- [Kind::Validator (ActiveModel::Validations)](#kindvalidator-activemodelvalidations)
+  - [Usage](#usage-1)
+    - [Defining the default validation strategy](#defining-the-default-validation-strategy)
+    - [Using the `allow_nil` and `strict` options](#using-the-allow_nil-and-strict-options)
 - [Kind::Undefined](#kindundefined)
   - [Kind.of.\<Type\>.or_undefined()](#kindoftypeor_undefined)
 - [Kind::Maybe](#kindmaybe)
-  - [Kind::Maybe[] and Kind::Maybe#then](#kindmaybe-and-kindmaybethen)
-  - [Kind::Maybe#try](#kindmaybetry)
+    - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas)
+  - [Kind::Maybe[] and Kind::Maybe#then method aliases](#kindmaybe-and-kindmaybethen-method-aliases)
+    - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas-1)
+  - [Kind::None() and Kind::Some()](#kindnone-and-kindsome)
   - [Kind.of.Maybe()](#kindofmaybe)
   - [Kind::Optional](#kindoptional)
+    - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas-2)
+  - [Kind.of.\<Type\>.as_optional](#kindoftypeas_optional)
+  - [Kind::Maybe#try](#kindmaybetry)
 - [Kind::Empty](#kindempty)
+- [Similar Projects](#similar-projects)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -76,14 +89,14 @@ sum(1, 1)   # 2
 sum('1', 1) # Kind::Error ("\"1\" expected to be a kind of Numeric")
 ```
 
-### Verifying the kind of some object
+### Kind.of.\<Type\>() - Verifying the kind of some object
 
 By default, basic verifications are strict. So, when you perform `Kind.of.Hash(value)`, if the given value was a Hash, the value itself will be returned, but if it isn't the right type, an error will be raised.
 
 ```ruby
-Kind.of.Hash(nil)    # **raise Kind::Error, "nil expected to be a kind of Hash"**
-Kind.of.Hash('')     # raise Kind::Error, "'' expected to be a kind of Hash"
-Kind.of.Hash({a: 1}) # {a: 1}
+Kind.of.Hash(nil)  # **raise Kind::Error, "nil expected to be a kind of Hash"**
+Kind.of.Hash('')   # raise Kind::Error, "'' expected to be a kind of Hash"
+Kind.of.Hash(a: 1) # {a: 1}
 
 # ---
 
@@ -92,6 +105,15 @@ Kind.of.Boolean(true)  # true
 Kind.of.Boolean(false) # false
 ```
 
+> **Note:** `Kind.of.<Type>` supports the to_proc protocol.
+> And it will perform a strict validation as expected.
+
+```ruby
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
+
+collection.map(&Kind.of.Hash) # Kind::Error ("number 2" expected to be a kind of Hash)
+```
+
 When the verified value is nil, it is possible to define a default value with the same type to be returned.
 
 ```ruby
@@ -104,7 +126,25 @@ Kind.of.Hash(value, or: {})    # {}
 Kind.of.Boolean(nil, or: true) # true
 ```
 
-As an alternative syntax, you can use the `Kind::Of` instead of the `Kind.of` method. e.g: `Kind::Of::Hash('')`
+> **Note:** As an alternative syntax, you can use the `Kind::Of` instead of the `Kind.of` method. e.g: `Kind::Of::Hash('')`
+
+#### Method aliases to perform a strict validation
+
+```ruby
+Kind.of.Hash[nil]  # raise Kind::Error, "nil expected to be a kind of Hash"
+Kind.of.Hash['']   # raise Kind::Error, "'' expected to be a kind of Hash"
+Kind.of.Hash[a: 1] # {a: 1}
+Kind.of.Hash['', or: {}] # {}
+
+# or
+
+Kind.of.Hash.instance(nil)  # raise Kind::Error, "nil expected to be a kind of Hash"
+Kind.of.Hash.instance('')   # raise Kind::Error, "'' expected to be a kind of Hash"
+Kind.of.Hash.instance(a: 1) # {a: 1}
+Kind.of.Hash.instance('', or: {}) # {}
+```
+
+### Kind.of.\<Type\>.or_nil()
 
 But if you don't need a strict type verification, use the `.or_nil` method.
 
@@ -118,36 +158,62 @@ Kind.of.Boolean.or_nil('')   # nil
 Kind.of.Boolean.or_nil(true) # true
 ```
 
-And just for convenience, you can use the method `.instance?` to verify if the given object has the expected type.
+### Kind.of.\<Type\>.instance?()
+
+Use the method `.instance?` to verify if the given object has the expected type.
 
 ```ruby
-Kind.of.Hash.instance?('')
-# false
+Kind.of.Hash.instance?({})                                # true
+Kind.of.Hash.instance?({}, HashWithIndifferentAccess.new) # true
+
+Kind.of.Hash.instance?('')     # false
+Kind.of.Hash.instance?({}, '') # false
 
 # ---
 
-Kind.of.Boolean.instance?('')    # false
-Kind.of.Boolean.instance?(true)  # true
-Kind.of.Boolean.instance?(false) # true
+Kind.of.Boolean.instance?(true)             # true
+Kind.of.Boolean.instance?(true, false)      # true
+
+Kind.of.Boolean.instance?(nil)              # false
+Kind.of.Boolean.instance?(false, true, nil) # false
 ```
 
-Also, there are aliases to perform the strict type verification. e.g:
+> **Note:** When `.instance?` is called without an argument,
+> it will return a lambda which will perform the kind verification.
 
 ```ruby
-Kind.of.Hash[nil]  # raise Kind::Error, "nil expected to be a kind of Hash"
-Kind.of.Hash['']   # raise Kind::Error, "'' expected to be a kind of Hash"
-Kind.of.Hash[a: 1] # {a: 1}
-Kind.of.Hash['', or: {}] # {}
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
-# or
+collection
+  .select(&Kind.of.Hash.instance?) # [{:number=>1}, {:number=>3}]
+```
 
-Kind.of.Hash.instance(nil)  # raise Kind::Error, "nil expected to be a kind of Hash"
-Kind.of.Hash.instance('')   # raise Kind::Error, "'' expected to be a kind of Hash"
-Kind.of.Hash.instance(a: 1) # {a: 1}
-Kind.of.Hash.instance('', or: {}) # {}
+> **Note:** You can use a different syntax to perform an instance verification.
+> To do this, use Kind.of.\<Type\>?()
+
+```ruby
+Kind.of.Hash?({})                                # true
+Kind.of.Hash?({}, HashWithIndifferentAccess.new) # true
+
+Kind.of.Hash?('')     # false
+Kind.of.Hash?({}, '') # false
+
+# ---
+
+Kind.of.Boolean?(true)        # true
+Kind.of.Boolean?(false, true) # true
+
+Kind.of.Boolean?(nil)              # false
+Kind.of.Boolean?(false, true, nil) # false
+
+# ---
+
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
+
+collection.select(&Kind.of.Hash?) # [{:number=>1}, {:number=>3}]
 ```
 
-### Verifying the kind of some class/module
+### Kind.is.\<Type\>() - Verifying if some class/module is the expected kind.
 
 You can use `Kind.is` to verify if some class has the expected type as its ancestor.
 
@@ -167,6 +233,49 @@ Kind.of.Hash.class?(Hash) # true
 Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess) # true
 ```
 
+> **Note:** The `Kind.is` could check the inheritance of Classes/Modules.
+
+```ruby
+#
+# Verifying if the attribute value is the class or a subclass.
+#
+class Human; end
+class Person < Human; end
+class User < Human; end
+
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
+
+Kind.is(Human, Struct) # false
+
+#
+# Verifying if the attribute value is the module or if it is a class that includes the module
+#
+module Human; end
+class Person; include Human; end
+class User; include Human; end
+
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
+
+Kind.is(Human, Struct) # false
+
+#
+# Verifying if the attribute value is the module or if it is a module that extends the module
+#
+module Human; end
+module Person; extend Human; end
+module User; extend Human; end
+
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
+
+Kind.is(Human, Struct) # false
+```
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ### How to create a new type checker?
@@ -191,6 +300,22 @@ Kind.of(User, {})   # Kind::Error ({} expected to be a kind of User)
 Kind.of(Hash, {})   # {}
 Kind.of(Hash, user) # Kind::Error (<User ...> expected to be a kind of Hash)
 
+# ----------------------------------------- #
+# Verifiyng if the value is a kind instance #
+# ----------------------------------------- #
+
+Kind.of?(Numeric, 1)      # true
+Kind.of?(Numeric, 1, 2.0) # true
+
+Kind.of?(Numeric, '1')      # false
+Kind.of?(Numeric, 1, '2.0') # false
+
+# Note: Kind.of?(Type) without arguments will return a
+#       lambda that will perform an instance verification
+#
+[1, '2', 3.0, '4']
+  .select(&Kind.of?(Numeric)) # [1, 3.0]
+
 # ---------------------------------- #
 # Creating type checkers dynamically #
 # ---------------------------------- #
@@ -205,6 +330,15 @@ kind_of_user.instance?(User) # true
 kind_of_user.class?(Hash)  # false
 kind_of_user.class?(User)  # true
 
+# ------------------------------------ #
+# Using methods which returns a lambda #
+# ------------------------------------ #
+collection = [User.new, User.new, 0, {} nil, User.new]
+
+collection.select(&Kind.of(User).instance?).size == 3 # true
+
+collection.map(&Kind.of(User).as_optional).select(&:some?).size == 3 # true
+
 # Creating type checkers dynamically is cheap
 # because a singleton object is created to be available for use.
 
@@ -220,7 +354,7 @@ end
 Kind.is(User, AdminUser) # true
 ```
 
-#### Registering new (custom) type checkers
+#### Registering new (custom) type checker
 
 Use `Kind::Types.add()`. e.g:
 
@@ -340,10 +474,162 @@ The list of types (classes and modules) available to use with `Kind.of.*` or `Ki
 - `Kind.of.Module()`
 - `Kind.of.Lambda()`
 - `Kind.of.Boolean()`
-- `Kind.of.Callable()`: verifies if the given value `respond_to?(:call)` or if it's a class/module and if its `public_instance_methods.include?(:call)`.
+- `Kind.of.Callable()`: verifies if the given value `respond_to?(:call)`.
 - `Kind.of.Maybe()` or its alias `Kind.of.Optional()`
 
-PS: Remember, you can use the `Kind.is.*` method to check if some given value is a class/module with all type checkers above.
+**Note:** Remember, you can use the `Kind.is.*` method to check if some given value is a class/module with all type checkers above.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+## Kind::Validator (ActiveModel::Validations)
+
+This module enables the capability to validate types via [`ActiveModel::Validations >= 3.2, < 6.1.0`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html). e.g
+
+```ruby
+class Person
+  include ActiveModel::Validations
+
+  attr_accessor :first_name, :last_name
+
+  validates :first_name, :last_name, kind: String
+end
+```
+
+And to make use of it, you will need to do an explicitly require. e.g:
+
+```ruby
+# In some Gemfile
+gem 'kind', require: 'kind/active_model/validation'
+
+# In some .rb file
+require 'kind/active_model/validation'
+```
+
+### Usage
+
+**[Object#kind_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-kind_of-3F)**
+
+```ruby
+validates :name, kind: { of: String }
+
+# Use an array to verify if the attribute
+# is an instance of one of the classes/modules.
+
+validates :status, kind: { of: [String, Symbol]}
+```
+
+**[Kind.is](#verifying-the-kind-of-some-classmodule)**
+
+```ruby
+#
+# Verifying if the attribute value is the class or a subclass.
+#
+class Human; end
+class Person < Human; end
+class User < Human; end
+
+validates :human_kind, kind: { is: Human }
+
+#
+# Verifying if the attribute value is the module or if it is a class that includes the module
+#
+module Human; end
+class Person; include Human; end
+class User; include Human; end
+
+validates :human_kind, kind: { is: Human }
+
+#
+# Verifying if the attribute value is the module or if it is a module that extends the module
+#
+module Human; end
+module Person; extend Human; end
+module User; extend Human; end
+
+validates :human_kind, kind: { is: Human }
+
+# or use an array to verify if the attribute
+# is a kind of one those classes/modules.
+
+validates :human_kind, kind: { is: [Person, User] }
+```
+
+**[Object#instance_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-instance_of-3F)**
+
+```ruby
+validates :name, kind: { instance_of: String }
+
+# or use an array to verify if the attribute
+# is an instance of one of the classes/modules.
+
+validates :name, kind: { instance_of: [String, Symbol] }
+```
+
+
+**[Object#respond_to?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-respond_to-3F)**
+
+```ruby
+validates :handler, kind: { respond_to: :call }
+```
+
+**Array.new.all? { |item| item.kind_of?(Class) }**
+
+```ruby
+validates :account_types, kind: { array_of: String }
+
+# or use an array to verify if the attribute
+# is an instance of one of the classes
+
+validates :account_types, kind: { array_of: [String, Symbol] }
+```
+
+**Array.new.all? { |item| expected_values.include?(item) }**
+
+```ruby
+# Verifies if the attribute value
+# is an array with some or all the expected values.
+
+validates :account_types, kind: { array_with: ['foo', 'bar'] }
+```
+
+#### Defining the default validation strategy
+
+By default, you can define the attribute type directly (without a hash). e.g.
+
+```ruby
+validates :name, kind: String
+# or
+validates :name, kind: [String, Symbol]
+```
+
+To changes this behavior you can set another strategy to validates the attributes types:
+
+```ruby
+Kind::Validator.default_strategy = :instance_of
+
+# Tip: Create an initializer if you are in a Rails application.
+```
+
+And these are the available options to define the default strategy:
+-  `kind_of` *(default)*
+-  `instance_of`
+
+#### Using the `allow_nil` and `strict` options
+
+You can use the `allow_nil` option with any of the kind validations. e.g.
+
+```ruby
+validates :name, kind: String, allow_nil: true
+```
+
+And as any active model validation, kind validations works with the `strict: true`
+option and with the `validates!` method. e.g.
+
+```ruby
+validates :first_name, kind: String, strict: true
+# or
+validates! :last_name, kind: String
+```
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -411,7 +697,27 @@ puts optional.value_or(1) # 1
 puts optional.value_or { 1 } # 1
 ```
 
-### Kind::Maybe[] and Kind::Maybe#then
+#### Replacing blocks by lambdas
+
+```ruby
+Add = -> params do
+  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
+
+  a + b if Kind.of.Numeric?(a, b)
+end
+
+# --
+
+  Kind::Maybe.new(a: 1, b: 2).map(&Add).value_or(0) # 3
+
+  # --
+
+  Kind::Maybe.new([]).map(&Add).value_or(0) # 0
+  Kind::Maybe.new({}).map(&Add).value_or(0) # 0
+  Kind::Maybe.new(nil).map(&Add).value_or(0) # 0
+```
+
+### Kind::Maybe[] and Kind::Maybe#then method aliases
 
 You can use `Kind::Maybe[]` (brackets) instead of the `.new` to transform values in a `Kind::Maybe`. Another alias is `.then` to the `.map` method.
 
@@ -425,39 +731,57 @@ result =
 puts result # 42
 ```
 
-### Kind::Maybe#try
-
-If you don't want to use a map to access the value, you could use the `#try` method to access it. So, if the value wasn't `nil` or `Kind::Undefined`, it will be returned.
+#### Replacing blocks by lambdas
 
 ```ruby
-object = 'foo'
+Add = -> params do
+  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
 
-p Kind::Maybe[object].try(:upcase) # "FOO"
+  a + b if Kind.of.Numeric.instance?(a, b)
+end
 
-p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+# --
 
-#############
-# Nil value #
-#############
+Kind::Maybe[a: 1, b: 2].then(&Add).value_or(0) # 3
 
-object = nil
+# --
 
-p Kind::Maybe[object].try(:upcase) # nil
+Kind::Maybe[1].then(&Add).value_or(0) # 0
+Kind::Maybe['2'].then(&Add).value_or(0) # 0
+Kind::Maybe[nil].then(&Add).value_or(0) # 0
+```
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
+### Kind::None() and Kind::Some()
 
-#########################
-# Kind::Undefined value #
-#########################
+If you need to ensure the return of  `Kind::Maybe` results from your methods/lambdas,
+you could use the methods `Kind::None` and `Kind::Some` to do this. e.g:
 
-object = Kind::Undefined
+```ruby
+Add = -> params do
+  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
 
-p Kind::Maybe[object].try(:upcase) # nil
+  return Kind::None unless Kind.of.Numeric?(a, b)
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
-```
+  Kind::Some(a + b)
+end
 
-[⬆️ Back to Top](#table-of-contents-)
+# --
+
+Add.call(1)    # #<Kind::Maybe::None:0x0000... @value=nil>
+Add.call({})   # #<Kind::Maybe::None:0x0000... @value=nil>
+Add.call(a: 1) # #<Kind::Maybe::None:0x0000... @value=nil>
+Add.call(b: 2) # #<Kind::Maybe::None:0x0000... @value=nil>
+
+Add.call(a:1, b: 2) # #<Kind::Maybe::Some:0x0000... @value=3>
+
+# --
+
+Kind::Maybe[a: 1, b: 2].then(&Add).value_or(0) # 3
+
+Kind::Maybe[1].then(&Add).value_or(0) # 0
+Kind::Maybe['2'].then(&Add).value_or(0) # 0
+Kind::Maybe[nil].then(&Add).value_or(0) # 0
+```
 
 ### Kind.of.Maybe()
 
@@ -514,7 +838,174 @@ result2 =
 puts result2 # 35
 ```
 
-PS: The `Kind.of.Optional` is available to check if some value is a `Kind::Optional`.
+#### Replacing blocks by lambdas
+
+```ruby
+Add = -> params do
+  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
+
+  a + b if Kind.of.Numeric.instance?(a, b)
+end
+
+# --
+
+Kind::Optional[a: 1, b: 2].then(&Add).value_or(0) # 3
+
+# --
+
+Kind::Optional[1].then(&Add).value_or(0) # 0
+Kind::Optional['2'].then(&Add).value_or(0) # 0
+Kind::Optional[nil].then(&Add).value_or(0) # 0
+```
+
+**Note:** The `Kind.of.Optional` is available to check if some value is a `Kind::Optional`.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Kind.of.\<Type\>.as_optional
+
+It is very common the need to avoid some computing when a method receives a wrong input.
+In these scenarios, you could check the given input type as optional and avoid unexpected behavior. e.g:
+
+```ruby
+def person_name(params)
+  Kind::Of::Hash.as_optional(params)
+                .map { |data| data if data.values_at(:first_name, :last_name).compact.size == 2 }
+                .map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+                .value_or { 'John Doe' }
+end
+
+person_name('')   # "John Doe"
+person_name(nil)  # "John Doe"
+
+person_name(first_name: 'Rodrigo')   # "John Doe"
+person_name(last_name: 'Serradura')  # "John Doe"
+
+person_name(first_name: 'Rodrigo', last_name: 'Serradura') # "Rodrigo Serradura"
+
+#
+# See below the previous implementation without using an optional.
+#
+def person_name(params)
+  if params.kind_of?(Hash) && params.values_at(:first_name, :last_name).compact.size == 2
+    "#{params[:first_name]} #{params[:last_name]}"
+  else
+    'John Doe'
+  end
+end
+```
+
+> Note: You could use the `.as_optional` method (or it alias `.as_maybe`) with any [type checker](https://github.com/serradura/kind/blob/b177fed9cc2b3347d63963a2a2fd99f989c51a9a/README.md#type-checkers).
+
+Let's see another example using a collection and how the method `.as_optional` works when it receives no argument.
+
+```ruby
+collection = [ {number: 1}, 'number 0', {number: 2}, [0] ]
+
+collection
+  .select(&Kind.of.Hash.as_optional)
+  .reduce(0) do |total, item|
+    item.try { |data| data[:number] + total } || total
+  end
+
+collection
+  .map(&Kind.of.Hash.as_optional).select(&:some?)
+  .reduce(0) { |total, item| total + item.value[:number] }
+
+# Note: All the examples above return 3 as the sum of all hashes with numbers.
+```
+
+To finish follows an example of how to use optionals to handle arguments in coupled methods.
+
+```ruby
+module PersonIntroduction
+  extend self
+
+  def call(params)
+    optional = Kind::Of::Hash.as_optional(params)
+
+    "Hi my name is #{full_name(optional)}, I'm #{age(optional)} years old."
+  end
+
+  private
+
+    def full_name(optional)
+      optional.map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+              .value_or { 'John Doe' }
+    end
+
+    def age(optional)
+      optional.map { |data| data[:age] }.value_or(0)
+    end
+end
+
+#
+# See below the previous implementation without using an optional.
+#
+module PersonIntroduction
+  extend self
+
+  def call(params)
+    "Hi my name is #{full_name(params)}, I'm #{age(params)} years old."
+  end
+
+  private
+
+    def full_name(params)
+      case params
+      when Hash then "#{params[:first_name]} #{params[:last_name]}"
+      else 'John Doe'
+      end
+    end
+
+    def age(params)
+      case params
+      when Hash then params.fetch(:age, 0)
+      else 0
+      end
+    end
+end
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Kind::Maybe#try
+
+If you don't want to use a map to access the value, you could use the `#try` method to access it. So, if the value wasn't `nil` or `Kind::Undefined`, it will be returned.
+
+```ruby
+object = 'foo'
+
+Kind::Maybe[object].try(:upcase) # "FOO"
+
+Kind::Maybe[{}].try(:fetch, :number, 0) # 0
+
+Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
+
+Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+
+#############
+# Nil value #
+#############
+
+object = nil
+
+Kind::Maybe[object].try(:upcase) # nil
+
+Kind::Maybe[object].try { |value| value.upcase } # nil
+
+#########################
+# Kind::Undefined value #
+#########################
+
+object = Kind::Undefined
+
+Kind::Maybe[object].try(:upcase) # nil
+
+Kind::Maybe[object].try { |value| value.upcase } # nil
+```
+
+> **Note:** You can use the try method with the `Kind::Optional`.
 
 [⬆️ Back to Top](#table-of-contents-)
 
@@ -565,6 +1056,10 @@ Follows the list of constants, if the alias is available to be created:
 
 [⬆️ Back to Top](#table-of-contents-)
 
+## Similar Projects
+
+- [dry-types](https://dry-rb.org/gems/dry-types)
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -575,7 +1070,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/serradura/kind. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/serradura/kind/blob/master/CODE_OF_CONDUCT.md).
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).