kind 2.2.0 → 4.0.0

data/Gemfile

@@ -12,9 +12,17 @@ activemodel = case activemodel_version
               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'
+              when '6.0' then '6.0.3.4'
+              when '6.1' then '6.1.2'
               end
 
+simplecov_version =
+  case RUBY_VERSION
+  when /\A2.[23]/ then '0.17.1'
+  when /\A2.4/ then '~> 0.18.5'
+  else '~> 0.19'
+  end
+
 group :test do
   if activemodel_version
     gem 'activesupport', activemodel, require: false
@@ -24,7 +32,7 @@ group :test do
     gem 'minitest', '~> 5.0'
   end
 
-  gem 'simplecov', require: false
+  gem 'simplecov', simplecov_version, require: false
 end
 
 gem 'rake', '~> 13.0'

data/README.md

@@ -1,61 +1,119 @@
-![Ruby](https://img.shields.io/badge/ruby-2.2+-ruby.svg?colorA=99004d&colorB=cc0066)
-[![Gem](https://img.shields.io/gem/v/kind.svg?style=flat-square)](https://rubygems.org/gems/kind)
-[![Build Status](https://travis-ci.com/serradura/kind.svg?branch=master)](https://travis-ci.com/serradura/kind)
-[![Maintainability](https://api.codeclimate.com/v1/badges/711329decb2806ccac95/maintainability)](https://codeclimate.com/github/serradura/kind/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/711329decb2806ccac95/test_coverage)](https://codeclimate.com/github/serradura/kind/test_coverage)
+<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>
+  <br>
+</p>
 
-# Kind <!-- omit in toc -->
+<p align="center">
+  <img src="https://img.shields.io/badge/ruby->%3D%202.2.0-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
 
-A simple type system (at runtime) for Ruby - free of dependencies.
+  <a href="https://rubygems.org/gems/kind">
+    <img alt="Gem" src="https://img.shields.io/gem/v/kind.svg?style=flat-square">
+  </a>
+
+  <a href="https://travis-ci.com/serradura/kind">
+    <img alt="Build Status" src="https://travis-ci.com/serradura/kind.svg?branch=master">
+  </a>
+
+  <a href="https://codeclimate.com/github/serradura/kind/maintainability">
+    <img alt="Maintainability" src="https://api.codeclimate.com/v1/badges/711329decb2806ccac95/maintainability">
+  </a>
+
+  <a href="https://codeclimate.com/github/serradura/kind/test_coverage">
+    <img alt="Test Coverage" src="https://api.codeclimate.com/v1/badges/711329decb2806ccac95/test_coverage">
+  </a>
+</p>
 
 **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, 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).
+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).
+
+## Documentation <!-- omit in toc -->
+
+Version    | Documentation
+---------- | -------------
+unreleased | https://github.com/serradura/u-case/blob/main/README.md
+4.0.0      | https://github.com/serradura/u-case/blob/v4.x/README.md
+3.1.0      | https://github.com/serradura/u-case/blob/v3.x/README.md
+2.3.0      | https://github.com/serradura/u-case/blob/v2.x/README.md
+1.9.0      | https://github.com/serradura/u-case/blob/v1.x/README.md
 
 ## Table of Contents <!-- omit in toc -->
-- [Required Ruby version](#required-ruby-version)
+- [Compatibility](#compatibility)
 - [Installation](#installation)
 - [Usage](#usage)
-  - [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 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.\<Type\>[]](#kindtype)
+  - [Kind::\<Type\>.===()](#kindtype-1)
+  - [Kind::\<Type\>.value?()](#kindtypevalue)
+  - [Kind::\<Type\>.or_nil()](#kindtypeor_nil)
+  - [Kind::\<Type\>.or_undefined()](#kindtypeor_undefined)
+  - [Kind::\<Type\>.or()](#kindtypeor)
+  - [Kind::\<Type\>.value()](#kindtypevalue-1)
+  - [Kind::\<Type\>?](#kindtype-2)
+  - [Kind::{Array,Hash,String,Set}.value_or_empty()](#kindarrayhashstringsetvalue_or_empty)
+  - [List of all type checkers (Kind::<Type>)](#list-of-all-type-checkers-kindtype)
+    - [Core](#core)
+    - [Stdlib](#stdlib)
+    - [Custom](#custom)
+  - [Creating type checkers](#creating-type-checkers)
+    - [Dynamic creation](#dynamic-creation)
+      - [Using a class or a module](#using-a-class-or-a-module)
+      - [Using an object which responds to ===](#using-an-object-which-responds-to-)
+    - [Kind::<Type> module](#kindtype-module)
+  - [Utility methods](#utility-methods)
+    - [Kind.of_class?()](#kindof_class)
+    - [Kind.of_module?()](#kindof_module)
+    - [Kind.of_module_or_class()](#kindof_module_or_class)
+    - [Kind.respond_to()](#kindrespond_to)
+    - [Kind.of()](#kindof)
+    - [Kind.of?()](#kindof-1)
+    - [Kind.value()](#kindvalue)
+    - [Kind.is()](#kindis)
+  - [Utility modules](#utility-modules)
+    - [Kind::Try](#kindtry)
+    - [Kind::Dig](#kinddig)
+    - [Kind::Presence](#kindpresence)
 - [Kind::Undefined](#kindundefined)
-  - [Kind.of.\<Type\>.or_undefined()](#kindoftypeor_undefined)
 - [Kind::Maybe](#kindmaybe)
     - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas)
-  - [Kind::Maybe[] and Kind::Maybe#then method aliases](#kindmaybe-and-kindmaybethen-method-aliases)
+  - [Kind::Maybe[], Kind::Maybe.wrap() and Kind::Maybe#then method aliases](#kindmaybe-kindmaybewrap-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(<Type>)](#kindmaybetype)
+    - [Real world examples](#real-world-examples)
+  - [Error handling](#error-handling)
+    - [Kind::Maybe.wrap {}](#kindmaybewrap-)
+    - [Kind::Maybe.map! or Kind::Maybe.then!](#kindmaybemap-or-kindmaybethen)
   - [Kind::Maybe#try](#kindmaybetry)
+  - [Kind::Maybe#try!](#kindmaybetry-1)
+  - [Kind::Maybe#dig](#kindmaybedig)
+  - [Kind::Maybe#check](#kindmaybecheck)
 - [Kind::Empty](#kindempty)
+- [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)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
 - [Code of Conduct](#code-of-conduct)
 
-## Required Ruby version
-> \>= 2.2.0
+## Compatibility
+
+| u-case         | branch  | ruby     |  activemodel   |
+| -------------- | ------- | -------- | -------------- |
+| unreleased     | main    | >= 2.2.0 | >= 3.2, <= 6.1 |
+| 4.0.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 |
+
+> Note: The activemodel is an optional dependency, it is related with the [Kind::Validator](#kindvalidator-activemodelvalidations).
 
 ## Installation
 
@@ -73,7 +131,7 @@ Or install it yourself as:
 
     $ gem install kind
 
-[⬆️ Back to Top](#table-of-contents-)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
 ## Usage
 
@@ -81,7 +139,7 @@ With this gem you can add some kind of type checking at runtime. e.g:
 
 ```ruby
 def sum(a, b)
-  Kind.of.Numeric(a) + Kind.of.Numeric(b)
+  Kind::Numeric[a] + Kind::Numeric[b]
 end
 
 sum(1, 1)   # 2
@@ -89,200 +147,194 @@ sum(1, 1)   # 2
 sum('1', 1) # Kind::Error ("\"1\" expected to be a kind of Numeric")
 ```
 
-### Kind.of.\<Type\>() - Verifying the kind of some object
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind.\<Type\>[]
 
-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.
+By default, basic verifications are strict. So, when you perform `Kind::Hash[value]` the given value will be returned if it was a Hash, but if not, 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::Hash[nil]  # Kind::Error (nil expected to be a kind of Hash)
+Kind::Hash['']   # Kind::Error ("" expected to be a kind of Hash)
+Kind::Hash[a: 1] # {a: 1}
+```
 
-# ---
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-Kind.of.Boolean(nil)   # raise Kind::Error, "nil expected to be a kind of Boolean"
-Kind.of.Boolean(true)  # true
-Kind.of.Boolean(false) # false
-```
+### Kind::\<Type\>.===()
 
-> **Note:** `Kind.of.<Type>` supports the to_proc protocol.
-> And it will perform a strict validation as expected.
+Use this method to verify if the given object has the expected type.
 
 ```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)
+Kind::Enumerable === {} # true
+Kind::Enumerable === '' # false
 ```
 
-When the verified value is nil, it is possible to define a default value with the same type to be returned.
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-```ruby
-value = nil
+### Kind::\<Type\>.value?()
 
-Kind.of.Hash(value, or: {})    # {}
+This method works like `.===`, but the difference is what happens when you invoke it without arguments.
 
-# ---
+```ruby
+# Example of calling `.value?` with an argument:
 
-Kind.of.Boolean(nil, or: true) # true
+Kind::Enumerable.value?({}) # true
+Kind::Enumerable.value?('') # false
 ```
 
-> **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
+When `.value?` is called without an argument, it will return a lambda which will know how to 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, [:number, 5] ]
 
-# 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: {}) # {}
+collection.select(&Kind::Enumerable.value?) # [{:number=>1}, {:number=>3}, [:number, 5]]
 ```
 
-### Kind.of.\<Type\>.or_nil()
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::\<Type\>.or_nil()
 
 But if you don't need a strict type verification, use the `.or_nil` method.
 
 ```ruby
-Kind.of.Hash.or_nil('')     # nil
-Kind.of.Hash.or_nil({a: 1}) # {a: 1}
-
-# ---
-
-Kind.of.Boolean.or_nil('')   # nil
-Kind.of.Boolean.or_nil(true) # true
+Kind::Hash.or_nil('')     # nil
+Kind::Hash.or_nil({a: 1}) # {a: 1}
 ```
 
-### Kind.of.\<Type\>.instance?()
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::\<Type\>.or_undefined()
 
-Use the method `.instance?` to verify if the given object has the expected type.
+This method works like `.or_nil`, but it will return a [`Kind::Undefined`](#kindundefined) instead of `nil`.
 
 ```ruby
-Kind.of.Hash.instance?({})                                # true
-Kind.of.Hash.instance?({}, HashWithIndifferentAccess.new) # true
+Kind::Hash.or_undefined('')     # Kind::Undefined
+Kind::Hash.or_undefined({a: 1}) # {a: 1}
+```
 
-Kind.of.Hash.instance?('')     # false
-Kind.of.Hash.instance?({}, '') # false
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-# ---
+### Kind::\<Type\>.or()
 
-Kind.of.Boolean.instance?(true)             # true
-Kind.of.Boolean.instance?(true, false)      # true
+This method can return a fallback if the given value isn't an instance of the expected kind.
 
-Kind.of.Boolean.instance?(nil)              # false
-Kind.of.Boolean.instance?(false, true, nil) # false
+```ruby
+Kind::Hash.or({}, [])      # {}
+Kind::Hash.or(nil, [])     # nil
+Kind::Hash.or(nil, {a: 1}) # {a: 1}
 ```
 
-> **Note:** When `.instance?` is called without an argument,
-> it will return a lambda which will perform the kind verification.
+If it doesn't receive a second argument (the value), it will return a callable that knows how to expose an instance of the expected type or a fallback if the given value is wrong.
 
 ```ruby
-collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4, [:number, 5] ]
 
-collection
-  .select(&Kind.of.Hash.instance?) # [{:number=>1}, {:number=>3}]
+collection.map(&Kind::Hash.or({}))  # [{:number=>1}, {}, {:number=>3}, {}, {}]
+collection.map(&Kind::Hash.or(nil)) # [{:number=>1}, nil, {:number=>3}, nil, nil]
 ```
 
-> **Note:** You can use a different syntax to perform an instance verification.
-> To do this, use Kind.of.\<Type\>?()
+An error will be raised if the fallback didn't have the expected kind or if not `nil` / `Kind::Undefined`.
 
 ```ruby
-Kind.of.Hash?({})                                # true
-Kind.of.Hash?({}, HashWithIndifferentAccess.new) # true
-
-Kind.of.Hash?('')     # false
-Kind.of.Hash?({}, '') # false
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4, [:number, 5] ]
 
-# ---
+collection.map(&Kind::Hash.or(:foo)) # Kind::Error (:foo expected to be a kind of Hash)
+```
 
-Kind.of.Boolean?(true)        # true
-Kind.of.Boolean?(false, true) # true
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-Kind.of.Boolean?(nil)              # false
-Kind.of.Boolean?(false, true, nil) # false
+### Kind::\<Type\>.value()
 
-# ---
+This method ensures that you will have a value of the expected kind. But, in the case of the given value be invalid, this method will require a default value (with the expected kind) to be returned.
+```ruby
+Kind::String.value(1, default: '')   # ""
 
-collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
+Kind::String.value('1', default: '') # "1"
 
-collection.select(&Kind.of.Hash?) # [{:number=>1}, {:number=>3}]
+Kind::String.value('1', default: 1)  # Kind::Error (1 expected to be a kind of String)
 ```
 
-### Kind.is.\<Type\>() - Verifying if some class/module is the expected kind.
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-You can use `Kind.is` to verify if some class has the expected type as its ancestor.
+### Kind::\<Type\>?
 
-```ruby
-Kind.is.Hash(String) # false
+There is a second way to do a type verification and know if one or multiple values has the expected type. You can use the predicate kind methods (`Kind::Hash?`). e.g:
 
-Kind.is.Hash(Hash)   # true
+```ruby
+# Verifying one value
+Kind::Enumerable?({}) # true
 
-Kind.is.Hash(ActiveSupport::HashWithIndifferentAccess) # true
+# Verifying multiple values
+Kind::Enumerable?({}, [], Set.new) # true
 ```
 
-And just for convenience, you can use the method `Kind.of.*.class?` to verify if the given class has the expected type as its ancestor.
+Like the `Kind::<Type>.value?` method, if the `Kind::<Type>?` doesn't receive an argument, it will return a lambda which will know how to perform the kind verification.
 
 ```ruby
-Kind.of.Hash.class?(Hash) # true
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4, [:number, 5] ]
 
-Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess) # true
+collection.select(&Kind::Enumerable?) # [{:number=>1}, {:number=>3}, [:number, 5]]
 ```
 
-> **Note:** The `Kind.is` could check the inheritance of Classes/Modules.
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::{Array,Hash,String,Set}.value_or_empty()
 
+This method is available for some type checkers (`Kind::Array`, `Kind::Hash`, `Kind::String`, `Kind::Set`), and it will return an empty frozen value if the given one hasn't the expected kind.
 ```ruby
-#
-# Verifying if the attribute value is the class or a subclass.
-#
-class Human; end
-class Person < Human; end
-class User < Human; end
+Kind::Array.value_or_empty({})         # []
+Kind::Array.value_or_empty({}).frozen? # true
+```
 
-Kind.is(Human, User)   # true
-Kind.is(Human, Human)  # true
-Kind.is(Human, Person) # true
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-Kind.is(Human, Struct) # false
+### List of all type checkers (Kind::<Type>)
 
-#
-# 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
+#### Core
 
-Kind.is(Human, User)   # true
-Kind.is(Human, Human)  # true
-Kind.is(Human, Person) # true
+* `Kind::Array`
+* `Kind::Class`
+* `Kind::Comparable`
+* `Kind::Enumerable`
+* `Kind::Enumerator`
+* `Kind::File`
+* `Kind::Float`
+* `Kind::Hash`
+* `Kind::Integer`
+* `Kind::IO`
+* `Kind::Method`
+* `Kind::Module`
+* `Kind::Numeric`
+* `Kind::Proc`
+* `Kind::Queue`
+* `Kind::Range`
+* `Kind::Regexp`
+* `Kind::String`
+* `Kind::Struct`
+* `Kind::Symbol`
+* `Kind::Time`
 
-Kind.is(Human, Struct) # false
+#### Stdlib
 
-#
-# 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::OpenStruct`
+* `Kind::Set`
 
-Kind.is(Human, User)   # true
-Kind.is(Human, Human)  # true
-Kind.is(Human, Person) # true
+#### Custom
 
-Kind.is(Human, Struct) # false
-```
+* `Kind::Boolean`
+* `Kind::Callable`
+* `Kind::Lambda`
+
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-[⬆️ Back to Top](#table-of-contents-)
+### Creating type checkers
 
-### How to create a new type checker?
+There are two ways to do this, you can create type checkers dynamically or defining a module.
 
-There are two ways to do this, you can create type checkers dynamically or register new ones.
+#### Dynamic creation
 
-#### Creating/Verifiyng type checkers dynamically
+##### Using a class or a module
 
 ```ruby
 class User
@@ -290,365 +342,476 @@ end
 
 user = User.new
 
-# ------------------------ #
-# Verifiyng the value kind #
-# ------------------------ #
+kind_of_user = Kind::Of(User)
 
-Kind.of(User, user) # <User ...>
-Kind.of(User, {})   # Kind::Error ({} expected to be a kind of User)
+# kind_of_user.name
+# kind_of_user.kind
+# The type checker can return its kind and its name
+kind_of_user.name # "User"
+kind_of_user.kind # User
 
-Kind.of(Hash, {})   # {}
-Kind.of(Hash, user) # Kind::Error (<User ...> expected to be a kind of Hash)
+# kind_of_user.===
+# Can check if a given value is an instance of its kind.
+kind_of_user === 0        # false
+kind_of_user === User.new # true
 
-# ----------------------------------------- #
-# Verifiyng if the value is a kind instance #
-# ----------------------------------------- #
+# kind_of_user.value?(value)
+# Can check if a given value is an instance of its kind.
+kind_of_user.value?('')       # false
+kind_of_user.value?(User.new) # true
 
-Kind.of?(Numeric, 1)      # true
-Kind.of?(Numeric, 1, 2.0) # true
+# If it doesn't receive an argument, a lambda will be returned and it will know how to do the type verification.
+[0, User.new].select?(&kind_of_user.value?) # [#<User:0x0000.... >]
 
-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]
+# kind_of_user.or_nil(value)
+# Can return nil if the given value isn't an instance of its kind
+kind_of_user.or_nil({})       # nil
+kind_of_user.or_nil(User.new) # #<User:0x0000.... >
 
-# ---------------------------------- #
-# Creating type checkers dynamically #
-# ---------------------------------- #
+# kind_of_user.or_undefined(value)
+# Can return Kind::Undefined if the given value isn't an instance of its kind
+kind_of_user.or_undefined([])       # Kind::Undefined
+kind_of_user.or_undefined(User.new) # #<User:0x0000.... >
 
-kind_of_user = Kind.of(User)
+# kind_of_user.or(fallback, value)
+# Can return a fallback if the given value isn't an instance of its kind
+kind_of_user.or(nil, 0)        # nil
+kind_of_user.or(nil, User.new) # #<User:0x0000.... >
 
-kind_of_user.or_nil({}) # nil
+# If it doesn't receive a second argument (the value), it will return a callable that knows how to expose an instance of the expected type or a fallback if the given value was wrong.
+[1, User.new].map(&kind_of_user.or(nil)) # [nil, #<User:0x0000.... >]
 
-kind_of_user.instance?({})   # false
-kind_of_user.instance?(User) # true
+# An error will be raised if the fallback didn't have the expected kind or if not nil / Kind::Undefined.
+[0, User.new].map(&kind_of_user.or(:foo)) # Kind::Error (:foo expected to be a kind of User)
 
-kind_of_user.class?(Hash)  # false
-kind_of_user.class?(User)  # true
+# kind_of_user[value]
+# Will raise Kind::Error if the given value isn't an instance of the expected kind
+kind_of_user[:foo]     # Kind::Error (:foo expected to be a kind of User)
+kind_of_user[User.new] # #<User:0x0000.... >
 
-# ------------------------------------ #
-# Using methods which returns a lambda #
-# ------------------------------------ #
-collection = [User.new, User.new, 0, {} nil, User.new]
+# kind_of_user.value(arg, default:)
+# This method ensures that you will have a value of the expected kind. But, in the case of the given value be invalid, this method will require a default value (with the expected kind) to be returned.
+kind_of_user.value(User.new, default: User.new) # #<User:0x0000...>
 
-collection.select(&Kind.of(User).instance?).size == 3 # true
+kind_of_user.value('1', default: User.new)      # #<User:0x0000...>
 
-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.
+kind_of_user.value('1', default: 1)  # Kind::Error (1 expected to be a kind of User)
+```
 
-kind_of_user.object_id == Kind.of(User).object_id # true
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-# --------------------------------------------- #
-# Kind.is() can be used to check a class/module #
-# --------------------------------------------- #
+##### Using an object which responds to ===
 
-class AdminUser < User
-end
+Example using a lambda (an object which responds to .===) and a hash with the kind name.
 
-Kind.is(User, AdminUser) # true
+```ruby
+PositiveInteger = Kind::Of(
+  -> value { value.kind_of?(Integer) && value > 0 },
+  name: 'PositiveInteger'
+)
+
+# PositiveInteger.name
+# PositiveInteger.kind
+# The type checker can return its kind and its name
+PositiveInteger.name # "PositiveInteger"
+PositiveInteger.kind # #<Proc:0x0000.... >
+
+# PositiveInteger.===
+# Can check if a given value is an instance of its kind.
+PositiveInteger === 1 # true
+PositiveInteger === 0 # false
+
+# PositiveInteger.value?(value)
+# Can check if a given value is an instance of its kind.
+PositiveInteger.value?(1)  # true
+PositiveInteger.value?(-1) # false
+
+# If it doesn't receive an argument, a lambda will be returned and it will know how to do the type verification.
+[1, 2, 0, 3, -1].select?(&PositiveInteger.value?) # [1, 2, 3]
+
+# PositiveInteger.or_nil(value)
+# Can return nil if the given value isn't an instance of its kind
+PositiveInteger.or_nil(1) # 1
+PositiveInteger.or_nil(0) # nil
+
+# PositiveInteger.or_undefined(value)
+# Can return Kind::Undefined if the given value isn't an instance of its kind
+PositiveInteger.or_undefined(2)  # 2
+PositiveInteger.or_undefined(-1) # Kind::Undefined
+
+# PositiveInteger.or(fallback, value)
+# Can return a fallback if the given value isn't an instance of its kind
+PositiveInteger.or(nil, 1) # 1
+PositiveInteger.or(nil, 0) # nil
+
+# If it doesn't receive a second argument (the value), it will return a callable that knows how to expose an instance of the expected type or a fallback if the given value was wrong.
+[1, 2, 0, 3, -1].map(&PositiveInteger.or(1))   # [1, 2, 1, 3, 1]
+[1, 2, 0, 3, -1].map(&PositiveInteger.or(nil)) # [1, 2, nil, 3, nil]
+
+# An error will be raised if the fallback didn't have the expected kind or if not nil / Kind::Undefined.
+[1, 2, 0, 3, -1].map(&PositiveInteger.or(:foo)) # Kind::Error (:foo expected to be a kind of PositiveInteger)
+
+# PositiveInteger[value]
+# Will raise Kind::Error if the given value isn't an instance of the expected kind
+PositiveInteger[1]    # 1
+PositiveInteger[:foo] # Kind::Error (:foo expected to be a kind of PositiveInteger)
+
+# PositiveInteger.value(arg, default:)
+# This method ensures that you will have a value of the expected kind. But, in the case of the given value be invalid, this method will require a default value (with the expected kind) to be returned.
+PositiveInteger.value(2, default: 1)   # 2
+
+PositiveInteger.value('1', default: 1) # 1
+
+PositiveInteger.value('1', default: 0) # Kind::Error (0 expected to be a kind of PositiveInteger)
 ```
 
-#### Registering new (custom) type checker
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-Use `Kind::Types.add()`. e.g:
+#### Kind::<Type> module
+
+The idea here is to create a type checker inside of the `Kind` namespace, so to do this, you will only need to use pure Ruby. e.g:
 
 ```ruby
 class User
 end
 
-# You can define it at the end of the file class/module where class/module was declared.
-
-Kind::Types.add(User)
+module Kind
+  module User
+    extend self, TypeChecker
 
-# Or, you can add the type checker within the class definition.
+    # Define the expected kind of this type checker.
+    def kind; ::User; end
+  end
 
-class User
-  Kind::Types.add(self)
+  # This how the Kind::<Type>? methods are defined.
+  def self.User?(*values)
+    KIND.of?(::User, values)
+  end
 end
 
-# --------------- #
-# Usage examples: #
-# --------------- #
-
-Kind.of.User(User.new)  # #<User:0x0000...>
+# Doing this you will have the same methods of a standard type checker (like: `Kind::Symbol`).
 
-Kind.of.User({})        # Kind::Error ({} expected to be a kind of User)
-
-Kind.of.User.or_nil({}) # nil
+user = User.new
 
-Kind.of.User.instance?({})   # false
-Kind.of.User.instance?(User) # true
+Kind::User[user] # #<User:0x0000...>
+Kind::User[{}]   # Kind::Error ({} expected to be a kind of User)
 
-Kind.of.User.class?(Hash)  # false
-Kind.of.User.class?(User)  # true
+Kind::User?(user) # true
+Kind::User?({})   # false
 ```
 
-[⬆️ Back to Top](#table-of-contents-)
+The advantages of this approach are:
 
-##### What happens if a custom type checker has a namespace?
+1. You will have a singleton (a unique instance) to be used, so the garbage collector will work less.
+2. You can define additional methods to be used with this kind.
 
-The type checker will preserve the namespace. ;)
+The disadvantage is:
 
-```ruby
-module Account
-  class User
-    Kind::Types.add(self)
-  end
-end
+1. You could overwrite some standard type checker or constant. I believe that this will be hard to happen, but must be your concern if you decide to use this kind of approach.
 
-module Account
-  class User
-    class Membership
-      Kind::Types.add(self)
-    end
-  end
-end
-
-Kind.of.Account::User({}) # Kind::Error ({} expected to be a kind of Account::User)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-Kind.of.Account::User(Account::User.new)  # #<Account::User:0x0000...>
+### Utility methods
 
-Kind.of.Account::User.or_nil({}) # nil
+#### Kind.of_class?()
 
-Kind.of.Account::User.instance?({})                # false
-Kind.of.Account::User.instance?(Account::User.new) # true
+This method verify if a given value is a `Class`.
 
-Kind.of.Account::User.class?(Hash)           # false
-Kind.of.Account::User.class?(Account::User)  # true
-
-# ---
-
-Kind.of.Account::User::Membership({}) # Kind::Error ({} expected to be a kind of Account::User::Membership)
+```ruby
+Kind.of_class?(Hash)       # true
+Kind.of_class?(Enumerable) # false
+Kind.of_class?(1)          # false
+```
 
-Kind.of.Account::User::Membership(Account::User::Membership.new)  # #<Account::User::Membership:0x0000...>
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-Kind.of.Account::User::Membership.or_nil({}) # nil
+#### Kind.of_module?()
 
-Kind.of.Account::User::Membership.instance?({})                            # false
-Kind.of.Account::User::Membership.instance?(Account::User::Membership.new) # true
+This method verify if a given value is a `Module`.
 
-Kind.of.Account::User::Membership.class?(Hash)                      # false
-Kind.of.Account::User::Membership.class?(Account::User::Membership) # true
+```ruby
+Kind.of_module?(Hash)       # false
+Kind.of_module?(Enumerable) # true
+Kind.of_module?(1)          # false
 ```
 
-[⬆️ Back to Top](#table-of-contents-)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-## Type checkers
+#### Kind.of_module_or_class()
 
-The list of types (classes and modules) available to use with `Kind.of.*` or `Kind.is.*` are:
+This method return the given value if it is a module or a class. If not, a `Kind::Error` will be raised.
 
-### Classes' type checkers
+```ruby
+Kind.of_module_or_class(String) # String
+Kind.of_module_or_class(1)      # Kind::Error (1 expected to be a kind of Module/Class)
+```
 
-- `Kind.of.String`
-- `Kind.of.Symbol`
-- `Kind.of.Numeric`
-- `Kind.of.Integer`
-- `Kind.of.Float`
-- `Kind.of.Regexp`
-- `Kind.of.Time`
-- `Kind.of.Array`
-- `Kind.of.Range`
-- `Kind.of.Hash`
-- `Kind.of.Struct`
-- `Kind.of.Enumerator`
-- `Kind.of.Set`
-- `Kind.of.Method`
-- `Kind.of.Proc`
-- `Kind.of.IO`
-- `Kind.of.File`
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-### Modules' type checkers
+#### Kind.respond_to()
 
-- `Kind.of.Enumerable`
-- `Kind.of.Comparable`
+this method returns the given object if it responds to all of the method names. But if the object does not respond to some of the expected methods, an error will be raised.
+  ```ruby
+  Kind.respond_to('', :upcase)         # ""
+  Kind.respond_to('', :upcase, :strip) # ""
 
-### Specials' type checkers
+  Kind.respond_to(1, :upcase)        # expected 1 to respond to :upcase
+  Kind.respond_to(2, :to_s, :upcase) # expected 2 to respond to :upcase
+  ```
 
-- `Kind.of.Class()`
-- `Kind.of.Module()`
-- `Kind.of.Lambda()`
-- `Kind.of.Boolean()`
-- `Kind.of.Callable()`: verifies if the given value `respond_to?(:call)`.
-- `Kind.of.Maybe()` or its alias `Kind.of.Optional()`
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-**Note:** Remember, you can use the `Kind.is.*` method to check if some given value is a class/module with all type checkers above.
+#### Kind.of()
 
-[⬆️ Back to Top](#table-of-contents-)
+There is a second way to do a strict type verification, you can use the `Kind.of()` method to do this. It receives the kind as the first argument and the value to be checked as the second one.
+```ruby
+Kind.of(Hash, {}) # {}
+Kind.of(Hash, []) # Kind::Error ([] expected to be a kind of Hash)
+```
 
-## Kind::Validator (ActiveModel::Validations)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-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
+#### Kind.of?()
+
+This method can be used to check if one or multiple values have the expected kind.
 
 ```ruby
-class Person
-  include ActiveModel::Validations
+# Checking one value
+Kind.of?(Array, []) # true
+Kind.of?(Array, {}) # false
+
+# Checking multiple values
+Kind.of?(Enumerable, [], {}) # true
+Kind.of?(Hash, {}, {})       # true
+Kind.of?(Array, [], {})      # false
+```
 
-  attr_accessor :first_name, :last_name
+If the method receives only the first argument (the kind) a lambda will be returned and it will know how to do the type verification.
 
-  validates :first_name, :last_name, kind: String
-end
+```ruby
+[1, '2', 3].select(&Kind.of?(Numeric)) # [1, 3]
 ```
 
-And to make use of it, you will need to do an explicitly require. e.g:
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
+#### Kind.value()
+
+This method ensures that you will have a value of the expected kind. But, in the case of the given value be invalid, this method will require a default value (with the expected kind) to be returned.
 ```ruby
-# In some Gemfile
-gem 'kind', require: 'kind/active_model/validation'
+Kind.value(String, '1', default: '') # "1"
 
-# In some .rb file
-require 'kind/active_model/validation'
+Kind.value(String, 1, default: '')   # ""
+
+Kind.value(String, 1, default: 2)    # Kind::Error (2 expected to be a kind of String)
 ```
 
-### Usage
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-**[Object#kind_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-kind_of-3F)**
+#### Kind.is()
+
+You can use `Kind.is` to verify if some class has the expected type as its ancestor.
 
 ```ruby
-validates :name, kind: { of: String }
+Kind.is(Hash, String) # false
 
-# Use an array to verify if the attribute
-# is an instance of one of the classes/modules.
+Kind.is(Hash, Hash)   # true
 
-validates :status, kind: { of: [String, Symbol]}
+Kind.is(Enumerable, Hash) # true
 ```
 
-**[Kind.is](#verifying-the-kind-of-some-classmodule)**
+The `Kind.is` also could check the inheritance of Classes/Modules.
 
 ```ruby
 #
-# Verifying if the attribute value is the class or a subclass.
+# Verifying if a class is or inherits from the expected class.
 #
 class Human; end
 class Person < Human; end
 class User < Human; end
 
-validates :human_kind, kind: { is: Human }
+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
+# Verifying if the classes included a module.
 #
 module Human; end
 class Person; include Human; end
 class User; include Human; end
 
-validates :human_kind, kind: { is: Human }
+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
+# Verifying if a class is or inherits from the expected 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.
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
 
-validates :human_kind, kind: { is: [Person, User] }
+Kind.is(Human, Struct) # false
 ```
 
-**[Object#instance_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-instance_of-3F)**
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Utility modules
+
+#### Kind::Try
+
+The method `.call` of this module invokes a public method with or without arguments like `public_send` does, except that if the receiver does not respond to it the call returns `nil` rather than raising an exception.
 
 ```ruby
-validates :name, kind: { instance_of: String }
+Kind::Try.(' foo ', :strip)        # "foo"
+Kind::Try.({a: 1}, :[], :a)        # 1
+Kind::Try.({a: 1}, :[], :b)        # nil
+Kind::Try.({a: 1}, :fetch, :b, 2)  # 2
 
-# or use an array to verify if the attribute
-# is an instance of one of the classes/modules.
+Kind::Try.(:symbol, :strip)        # nil
+Kind::Try.(:symbol, :fetch, :b, 2) # nil
 
-validates :name, kind: { instance_of: [String, Symbol] }
+# It raises an exception if the method name isn't a string or a symbol
+Kind::Try.({a: 1}, 1, :a) # TypeError (1 is not a symbol nor a string)
 ```
 
-
-**[Object#respond_to?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-respond_to-3F)**
+This module has the method `[]` that knows how to create a lambda that will know how to perform the `try` strategy.
 
 ```ruby
-validates :handler, kind: { respond_to: :call }
+results =
+  [
+    {},
+    {name: 'Foo Bar'},
+    {name: 'Rodrigo Serradura'},
+  ].map(&Kind::Try[:fetch, :name, 'John Doe'])
+
+p results # ["John Doe", "Foo Bar", "Rodrigo Serradura"]
 ```
 
-**Array.new.all? { |item| item.kind_of?(Class) }**
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+#### Kind::Dig
+
+The method `.call` of this module has the same behavior of Ruby dig methods ([Hash](https://ruby-doc.org/core-2.3.0/Hash.html#method-i-dig), [Array](https://ruby-doc.org/core-2.3.0/Array.html#method-i-dig), [Struct](https://ruby-doc.org/core-2.3.0/Struct.html#method-i-dig), [OpenStruct](https://ruby-doc.org/stdlib-2.3.0/libdoc/ostruct/rdoc/OpenStruct.html#method-i-dig)), but it will not raise an error if some step can't be digged.
 
 ```ruby
-validates :account_types, kind: { array_of: String }
+s = Struct.new(:a, :b).new(101, 102)
+o = OpenStruct.new(c: 103, d: 104)
+d = { struct: s, ostruct: o, data: [s, o]}
 
-# or use an array to verify if the attribute
-# is an instance of one of the classes
+Kind::Dig.(s, [:a])            # 101
+Kind::Dig.(o, [:c])            # 103
 
-validates :account_types, kind: { array_of: [String, Symbol] }
+Kind::Dig.(d, [:struct, :b])   # 102
+Kind::Dig.(d, [:data, 0, :b])  # 102
+Kind::Dig.(d, [:data, 0, 'b']) # 102
+
+Kind::Dig.(d, [:ostruct, :d])  # 104
+Kind::Dig.(d, [:data, 1, :d])  # 104
+Kind::Dig.(d, [:data, 1, 'd']) # 104
+
+Kind::Dig.(d, [:struct, :f])   # nil
+Kind::Dig.(d, [:ostruct, :f])  # nil
+Kind::Dig.(d, [:data, 0, :f])  # nil
+Kind::Dig.(d, [:data, 1, :f])  # nil
 ```
 
-**Array.new.all? { |item| expected_values.include?(item) }**
+Another difference between the `Kind::Dig` and the native Ruby dig, is that it knows how to extract values from regular objects.
 
 ```ruby
-# Verifies if the attribute value
-# is an array with some or all the expected values.
+class Person
+  attr_reader :name
 
-validates :account_types, kind: { array_with: ['foo', 'bar'] }
-```
+  def initialize(name)
+    @name = name
+  end
+end
 
-#### Defining the default validation strategy
+person = Person.new('Rodrigo')
 
-By default, you can define the attribute type directly (without a hash). e.g.
+Kind::Dig.(person, [:name])                         # "Rodrigo"
 
-```ruby
-validates :name, kind: String
-# or
-validates :name, kind: [String, Symbol]
+Kind::Dig.({people: [person]}, [:people, 0, :name]) # "Rodrigo"
 ```
 
-To changes this behavior you can set another strategy to validates the attributes types:
+This module has the method `[]` that knows how to create a lambda that will know how to perform the `dig` strategy.
 
 ```ruby
-Kind::Validator.default_strategy = :instance_of
+results = [
+  { person: {} },
+  { person: { name: 'Foo Bar'} },
+  { person: { name: 'Rodrigo Serradura'} },
+].map(&Kind::Dig[:person, :name])
 
-# Tip: Create an initializer if you are in a Rails application.
+p results # [nil, "Foo Bar", "Rodrigo Serradura"],
 ```
 
-And these are the available options to define the default strategy:
--  `kind_of` *(default)*
--  `instance_of`
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-#### Using the `allow_nil` and `strict` options
+#### Kind::Presence
 
-You can use the `allow_nil` option with any of the kind validations. e.g.
+The method `.call` of this module returns the given value if it's present otherwise it will return `nil`.
 
 ```ruby
-validates :name, kind: String, allow_nil: true
+Kind::Presence.(true)         # true
+Kind::Presence.('foo')        # "foo"
+Kind::Presence.([1, 2])       # [1, 2]
+Kind::Presence.({a: 3})       # {a: 3}
+Kind::Presence.(Set.new([4])) # #<Set: {4}>
+
+Kind::Presence.('')       # nil
+Kind::Presence.('   ')    # nil
+Kind::Presence.("\t\n\r") # nil
+Kind::Presence.("\u00a0") # nil
+
+Kind::Presence.([])       # nil
+Kind::Presence.({})       # nil
+Kind::Presence.(Set.new)  # nil
+
+Kind::Presence.(nil)      # nil
+Kind::Presence.(false)    # nil
+
+# nil will be returned if the given object responds to the method blank? and this method result is true.
+MyObject = Struct.new(:is_blank) do
+  def blank?
+    is_blank
+  end
+end
+
+my_object = MyObject.new
+
+my_object.is_blank = true
+
+Kind::Presence.(my_object) # nil
+
+my_object.is_blank = false
+
+Kind::Presence.(my_object) # #<struct MyObject is_blank=false>
 ```
 
-And as any active model validation, kind validations works with the `strict: true`
-option and with the `validates!` method. e.g.
+This module also has the method `to_proc`, because of this you can make use of the `Kind::Presence` in methods that receive a block as an argument. e.g:
 
 ```ruby
-validates :first_name, kind: String, strict: true
-# or
-validates! :last_name, kind: String
+  ['', [], {}, '1', [2]].map(&Kind::Presence) # [nil, nil, nil, "1", [2]]
 ```
 
-[⬆️ Back to Top](#table-of-contents-)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
 ## Kind::Undefined
 
-The [`Kind::Undefined`](https://github.com/serradura/kind/blob/834f6b8ebdc737de8e5628986585f30c1a5aa41b/lib/kind/undefined.rb) constant is used as the default argument of type checkers. This is necessary [to know if no arguments were passed to the type check methods](https://github.com/serradura/kind/blob/834f6b8ebdc737de8e5628986585f30c1a5aa41b/lib/kind.rb#L45-L48). But, you can use it in your codebase too, especially if you need to distinguish the usage of `nil` as a method argument.
-
-If you are interested, check out [the tests](https://github.com/serradura/kind/blob/834f6b8ebdc737de8e5628986585f30c1a5aa41b/test/kind/undefined_test.rb) to understand its methods.
+The [`Kind::Undefined`](https://github.com/serradura/kind/blob/1674bab/lib/kind/undefined.rb) constant can be used to distinguish the usage of `nil`.
 
-### Kind.of.\<Type\>.or_undefined()
+If you are interested, check out [the tests](https://github.com/serradura/kind/blob/main/test/kind/undefined_test.rb) to understand its methods.
 
-If you interested in use `Kind::Undefined` you can use the method `.or_undefined` with any of the [available type checkers](#type-checkers). e.g:
-
-```ruby
-Kind.of.String.or_undefined(nil)         # Kind::Undefined
-Kind.of.String.or_undefined("something") # "something"
-```
-
-[⬆️ Back to Top](#table-of-contents-)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
 ## Kind::Maybe
 
@@ -697,13 +860,15 @@ puts optional.value_or(1) # 1
 puts optional.value_or { 1 } # 1
 ```
 
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
 #### Replacing blocks by lambdas
 
 ```ruby
 Add = -> params do
-  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
+  a, b = Kind::Hash.value_or_empty(params).values_at(:a, :b)
 
-  a + b if Kind.of.Numeric?(a, b)
+  a + b if Kind::Numeric?(a, b)
 end
 
 # --
@@ -717,7 +882,9 @@ end
   Kind::Maybe.new(nil).map(&Add).value_or(0) # 0
 ```
 
-### Kind::Maybe[] and Kind::Maybe#then method aliases
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::Maybe[], Kind::Maybe.wrap() 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.
 
@@ -731,13 +898,28 @@ result =
 puts result # 42
 ```
 
+You can also use `Kind::Maybe.wrap()` instead of the `.new` method.
+
+```ruby
+result =
+  Kind::Maybe
+    .wrap(5)
+    .then { |value| value * 5 }
+    .then { |value| value + 17 }
+    .value_or(0)
+
+puts result # 42
+```
+
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
 #### Replacing blocks by lambdas
 
 ```ruby
 Add = -> params do
-  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
+  a, b = Kind::Hash.value_or_empty(params).values_at(:a, :b)
 
-  a + b if Kind.of.Numeric.instance?(a, b)
+  a + b if Kind::Numeric?(a, b)
 end
 
 # --
@@ -751,16 +933,24 @@ Kind::Maybe['2'].then(&Add).value_or(0) # 0
 Kind::Maybe[nil].then(&Add).value_or(0) # 0
 ```
 
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
 ### Kind::None() and Kind::Some()
 
 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:
 
 ```ruby
+Double = ->(arg) do
+  number = Kind::Numeric.or_nil(arg)
+
+  Kind::Maybe[number].then { |number| number * 2 }
+end
+
 Add = -> params do
-  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
+  a, b = Kind::Hash.value_or_empty(params).values_at(:a, :b)
 
-  return Kind::None unless Kind.of.Numeric?(a, b)
+  return Kind::None unless Kind::Numeric?(a, b)
 
   Kind::Some(a + b)
 end
@@ -779,40 +969,14 @@ 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()
-
-You can use the `Kind.of.Maybe()` to know if the given value is a kind of `Kind::Maybe`object. e.g:
-
-```ruby
-def double(maybe_number)
-  Kind.of.Maybe(maybe_number)
-    .map { |value| value * 2 }
-    .value_or(0)
-end
-
-number = Kind::Maybe[4]
-
-puts double(number) # 8
-
-# -------------------------------------------------------#
-# All the type checker methods are available to use too. #
-# -------------------------------------------------------#
 
-Kind.of.Maybe.instance?(number) # true
-
-Kind.of.Maybe.or_nil(number) # <Kind::Maybe::Some @value=4 ...>
-
-Kind.of.Maybe.instance(number) # <Kind::Maybe::Some @value=4 ...>
-Kind.of.Maybe.instance(4) # Kind::Error (4 expected to be a kind of Kind::Maybe::Result)
+# --
 
-Kind.of.Maybe[number] # <Kind::Maybe::Some @value=4 ...>
-Kind.of.Maybe[4] # Kind::Error (4 expected to be a kind of Kind::Maybe::Result)
+Add.(a: 2, b: 2).then(&Double).value # 8
 ```
 
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
 ### Kind::Optional
 
 The `Kind::Optional` constant is an alias for `Kind::Maybe`. e.g:
@@ -838,41 +1002,81 @@ result2 =
 puts result2 # 35
 ```
 
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
 #### Replacing blocks by lambdas
 
 ```ruby
-Add = -> params do
-  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
+Double = ->(arg) do
+  number = Kind::Numeric.or_nil(arg)
 
-  a + b if Kind.of.Numeric.instance?(a, b)
+  Kind::Maybe[number].then { |number| number * 2 }
 end
 
 # --
 
-Kind::Optional[a: 1, b: 2].then(&Add).value_or(0) # 3
+Kind::Optional[2].then(&Double).value_or(0) # 4
 
 # --
 
-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
+Kind::Optional['2'].then(&Double).value_or(0) # 0
+Kind::Optional[nil].then(&Double).value_or(0) # 0
 ```
 
-**Note:** The `Kind.of.Optional` is available to check if some value is a `Kind::Optional`.
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::Maybe(<Type>)
+
+You can use `Kind::Maybe(<Type>)` or `Kind::Optional(<Type>)` to create a maybe monad which will return None if the given input hasn't the expected type. e.g:
 
-[⬆️ Back to Top](#table-of-contents-)
+```ruby
+result1 =
+  Kind::Maybe(Numeric)
+    .wrap(5)
+    .then { |value| value * 5 }
+    .value_or { 0 }
 
-### Kind.of.\<Type\>.as_optional
+puts result1 # 25
 
-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:
+# ---
+
+result2 =
+  Kind::Optional(Numeric)
+    .wrap('5')
+    .then { |value| value * 5 }
+    .value_or { 0 }
+
+puts result2 # 0
+```
+
+This typed maybe has the same methods of `Kind::Maybe` class. e.g:
+
+```ruby
+Kind::Maybe(Numeric)[5]
+Kind::Maybe(Numeric).new(5)
+Kind::Maybe(Numeric).wrap(5)
+
+# ---
+
+Kind::Optional(Numeric)[5]
+Kind::Optional(Numeric).new(5)
+Kind::Optional(Numeric).wrap(5)
+```
+
+#### Real world examples
+
+It is very common the need to avoid some operation when a method receives the wrong input.
+In these scenarios, you could create a maybe monad that will return None if the given input hasn't the expected type. 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' }
+  Kind::Maybe(Hash)
+    .wrap(params)
+    .then  { |hash| hash.values_at(:first_name, :last_name) }
+    .then  { |names| names.map(&Kind::Presence).tap(&:compact!) }
+    .check { |names| names.size == 2 }
+    .then  { |(first_name, last_name)| "#{first_name} #{last_name}" }
+    .value_or { 'John Doe' }
 end
 
 person_name('')   # "John Doe"
@@ -884,45 +1088,31 @@ 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.
+# See below the previous implementation without using the maybe monad.
 #
 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).
+  default = 'John Doe'
 
-Let's see another example using a collection and how the method `.as_optional` works when it receives no argument.
+  return default unless params.kind_of?(Hash)
 
-```ruby
-collection = [ {number: 1}, 'number 0', {number: 2}, [0] ]
+  names = params.values_at(:first_name, :last_name).map(&Kind::Presence).tap(&:compact!)
 
-collection
-  .select(&Kind.of.Hash.as_optional)
-  .reduce(0) do |total, item|
-    item.try { |data| data[:number] + total } || total
-  end
+  return default if names.size != 2
 
-collection
-  .map(&Kind.of.Hash.as_optional).select(&:some?)
-  .reduce(0) { |total, item| total + item.value[:number] }
+  first_name, last_name = default
 
-# Note: All the examples above return 3 as the sum of all hashes with numbers.
+  "#{first_name} #{last_name}"
+end
 ```
 
-To finish follows an example of how to use optionals to handle arguments in coupled methods.
+To finish follows an example of how to use the Maybe monad to handle arguments in coupled methods.
 
 ```ruby
-module PersonIntroduction
+module PersonIntroduction1
   extend self
 
   def call(params)
-    optional = Kind::Of::Hash.as_optional(params)
+    optional = Kind::Maybe(Hash).wrap(params)
 
     "Hi my name is #{full_name(optional)}, I'm #{age(optional)} years old."
   end
@@ -930,19 +1120,20 @@ module PersonIntroduction
   private
 
     def full_name(optional)
-      optional.map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+      optional.map { |hash| "#{hash[:first_name]} #{hash[:last_name]}".strip }
+              .presence
               .value_or { 'John Doe' }
     end
 
     def age(optional)
-      optional.map { |data| data[:age] }.value_or(0)
+      optional.map { |hash| hash[:age] }.value_or(0)
     end
 end
 
 #
 # See below the previous implementation without using an optional.
 #
-module PersonIntroduction
+module PersonIntroduction2
   extend self
 
   def call(params)
@@ -952,9 +1143,12 @@ module PersonIntroduction
   private
 
     def full_name(params)
+      default = 'John Doe'
+
       case params
-      when Hash then "#{params[:first_name]} #{params[:last_name]}"
-      else 'John Doe'
+      when Hash then
+        Kind::Presence.("#{params[:first_name]} #{params[:last_name]}".strip) || default
+      else default
       end
     end
 
@@ -967,22 +1161,64 @@ module PersonIntroduction
 end
 ```
 
-[⬆️ Back to Top](#table-of-contents-)
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Error handling
+
+#### Kind::Maybe.wrap {}
+
+The `Kind::Maybe#wrap` can receive a block, and if an exception (at `StandardError level`) happening, this will generate a None result.
+
+```ruby
+Kind::Maybe(Numeric)
+  .wrap { 2 / 0 } # #<Kind::Maybe::None:0x0000... @value=#<ZeroDivisionError: divided by 0>>
+
+Kind::Maybe(Numeric)
+  .wrap(2) { |number| number / 0 } # #<Kind::Maybe::None:0x0000... @value=#<ZeroDivisionError: divided by 0>>
+```
+
+#### Kind::Maybe.map! or Kind::Maybe.then!
+
+By default the `Kind::Maybe#map` and `Kind::Maybe#then` intercept exceptions at the `StandardError` level. So if an exception was intercepted a None will be returned.
+
+```ruby
+# Handling StandardError exceptions
+result1 = Kind::Maybe[2].map { |number| number / 0 }
+result1.none? # true
+result1.value # #<ZeroDivisionError: divided by 0>
+
+result2 = Kind::Maybe[3].then { |number| number / 0 }
+result2.none? # true
+result2.value # #<ZeroDivisionError: divided by 0>
+```
+
+But there are versions of these methods (`Kind::Maybe#map!` and `Kind::Maybe#then!`) that allow the exception leak, so, the user must handle the exception by himself or use this method when he wants to see the error be raised.
+
+```ruby
+# Leaking StandardError exceptions
+Kind::Maybe[2].map! { |number| number / 0 } # ZeroDivisionError (divided by 0)
+
+Kind::Maybe[2].then! { |number| number / 0 } # ZeroDivisionError (divided by 0)
+```
+
+> **Note:** If an exception (at StandardError level) is returned by the methods `#then`, `#map` it will be resolved as None.
+
+[⬆️ &nbsp;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.
+If you don't want to use `#map/#then` to access the value, you could use the `#try` method to access it. So, if the value wasn't `nil` or `Kind::Undefined`, the some monad will be returned.
 
 ```ruby
 object = 'foo'
 
-Kind::Maybe[object].try(:upcase) # "FOO"
+Kind::Maybe[object].try(:upcase).value # "FOO"
 
-Kind::Maybe[{}].try(:fetch, :number, 0) # 0
+Kind::Maybe[{}].try(:fetch, :number, 0).value # 0
 
-Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
+Kind::Maybe[{number: 1}].try(:fetch, :number).value # 1
 
-Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+Kind::Maybe[object].try { |value| value.upcase }.value # "FOO"
 
 #############
 # Nil value #
@@ -990,9 +1226,9 @@ Kind::Maybe[object].try { |value| value.upcase } # "FOO"
 
 object = nil
 
-Kind::Maybe[object].try(:upcase) # nil
+Kind::Maybe[object].try(:upcase).value # nil
 
-Kind::Maybe[object].try { |value| value.upcase } # nil
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
 
 #########################
 # Kind::Undefined value #
@@ -1000,14 +1236,105 @@ Kind::Maybe[object].try { |value| value.upcase } # nil
 
 object = Kind::Undefined
 
-Kind::Maybe[object].try(:upcase) # nil
+Kind::Maybe[object].try(:upcase).value # nil
 
-Kind::Maybe[object].try { |value| value.upcase } # nil
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
 ```
 
-> **Note:** You can use the try method with the `Kind::Optional`.
+> **Note:** You can use the `#try` method with `Kind::Optional` objects.
+
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::Maybe#try!
+
+Has the same behavior of its `#try`, but it will raise an error if the value doesn't respond to the expected method.
 
-[⬆️ Back to Top](#table-of-contents-)
+```ruby
+Kind::Maybe[{}].try(:upcase)  # => #<Kind::Maybe::None:0x0000... @value=nil>
+
+Kind::Maybe[{}].try!(:upcase) # => NoMethodError (undefined method `upcase' for {}:Hash)
+```
+
+> **Note:** You can also use the `#try!` method with `Kind::Optional` objects.
+
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
+
+### Kind::Maybe#dig
+
+Has the same behavior of Ruby dig methods ([Hash](https://ruby-doc.org/core-2.3.0/Hash.html#method-i-dig), [Array](https://ruby-doc.org/core-2.3.0/Array.html#method-i-dig), [Struct](https://ruby-doc.org/core-2.3.0/Struct.html#method-i-dig), [OpenStruct](https://ruby-doc.org/stdlib-2.3.0/libdoc/ostruct/rdoc/OpenStruct.html#method-i-dig)), but it will not raise an error if some value can't be digged.
+
+```ruby
+[nil, 1, '', /x/].each do |value|
+  p Kind::Maybe[value].dig(:foo).value # nil
+end
+
+# --
+
+a = [1, 2, 3]
+
+Kind::Maybe[a].dig(0).value # 1
+
+Kind::Maybe[a].dig(3).value # nil
+
+# --
+
+h = { foo: {bar: {baz: 1}}}
+
+Kind::Maybe[h].dig(:foo).value             # {bar: {baz: 1}}
+Kind::Maybe[h].dig(:foo, :bar).value       # {baz: 1}
+Kind::Maybe[h].dig(:foo, :bar, :baz).value # 1
+
+Kind::Maybe[h].dig(:foo, :bar, 'baz').value # nil
+
+# --
+
+i = { foo: [{'bar' => [1, 2]}, {baz: [3, 4]}] }
+
+Kind::Maybe[i].dig(:foo, 0, 'bar', 0).value # 1
+Kind::Maybe[i].dig(:foo, 0, 'bar', 1).value # 2
+Kind::Maybe[i].dig(:foo, 0, 'bar', -1).value # 2
+
+Kind::Maybe[i].dig(:foo, 0, 'bar', 2).value # nil
+
+# --
+
+s = Struct.new(:a, :b).new(101, 102)
+o = OpenStruct.new(c: 103, d: 104)
+b = { struct: s, ostruct: o, data: [s, o]}
+
+Kind::Maybe[s].dig(:a).value            # 101
+Kind::Maybe[b].dig(:struct, :b).value   # 102
+Kind::Maybe[b].dig(:data, 0, :b).value  # 102
+Kind::Maybe[b].dig(:data, 0, 'b').value # 102
+
+Kind::Maybe[o].dig(:c).value            # 103
+Kind::Maybe[b].dig(:ostruct, :d).value  # 104
+Kind::Maybe[b].dig(:data, 1, :d).value  # 104
+Kind::Maybe[b].dig(:data, 1, 'd').value # 104
+
+Kind::Maybe[s].dig(:f).value           # nil
+Kind::Maybe[o].dig(:f).value           # nil
+Kind::Maybe[b].dig(:struct, :f).value  # nil
+Kind::Maybe[b].dig(:ostruct, :f).value # nil
+Kind::Maybe[b].dig(:data, 0, :f).value # nil
+Kind::Maybe[b].dig(:data, 1, :f).value # nil
+```
+
+> **Note:** You can also use the `#dig` method with `Kind::Optional` objects.
+
+### Kind::Maybe#check
+
+This method will return the current Some after verify if the block output is truthy. e.g:
+
+```ruby
+Kind::Maybe(Array)
+  .wrap(['Rodrigo', 'Serradura'])
+  .then  { |names| names.map(&Kind::Presence).tap(&:compact!) }
+  .check { |names| names.size == 2 }
+  .value # ["Rodrigo", "Serradura"]
+```
+
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
 ## Kind::Empty
 
@@ -1054,7 +1381,158 @@ Follows the list of constants, if the alias is available to be created:
 - `Empty::ARRAY`
 - `Empty::STRING`
 
-[⬆️ Back to Top](#table-of-contents-)
+[⬆️ &nbsp;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
+```
+
+[⬆️ &nbsp;Back to Top](#table-of-contents-)
 
 ## Similar Projects