kind 1.9.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d4f4be415e28c7f240a097a64626588e7b3c7bc8a70dbfd71bf2b5b426e016a
-  data.tar.gz: 7401efa30206d27d4f10608b5164d6c334d8da02e4652d8a7f156ee081f18ec5
+  metadata.gz: a0a947ffbd4a82b5ca7a74006ae8383c725393e1e8640364dc9e73874aac0eb0
+  data.tar.gz: d49f7382d4786e079c42ee7f45609ca8ca292ccb04e4d8ac299cdfa4cbf2e1c8
 SHA512:
-  metadata.gz: f672462c9e64afce93af792d179d1c6095003ade48329018f4e64eb0bae7fb825699f2350c643fa2a1f2a3ae2822b3cbb1e8444c3a423101a37beffadbd7a614
-  data.tar.gz: 890957443724fe3fdd7fec56d8b4a87c0e92f2793d26d298b8347b75e7091612e36a87d29bae70c7a789fe9e0750b366a4fe572104351e55b04903bbfcbffe03
+  metadata.gz: 77195516f80bae446150221c3c95a621ecacb70335f4594242b3d7f60e9de7ed5be32624c02183faf1ab5cc4717b0c229c82c52ec70aad6122d1fe51a71dfc92
+  data.tar.gz: 1f7ab4c70b8548dda0707d31ba9d500946c5314d8d9462ecdcd5ca0b23f1a197691d0eb6586e4a1628426794f1495d0303d2b1b7c4b32a1bcc73fdc88ea1123b

data/.travis.yml

@@ -3,7 +3,10 @@ language: ruby
 
 sudo: false
 
-cache: bundler
+cache:
+  bundler: true
+  directories:
+    - /home/travis/.rvm/
 
 rvm:
   - 2.2.0

data/README.md

@@ -18,28 +18,37 @@ One of the goals of this project is to do simple type checking like `"some strin
 - [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[], 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::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::Maybe(<Type>)](#kindmaybetype)
+  - [Kind::Maybe#try](#kindmaybetry)
+  - [Kind::Maybe#try!](#kindmaybetry-1)
 - [Kind::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
@@ -82,14 +91,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}
 
 # ---
 
@@ -99,14 +108,12 @@ Kind.of.Boolean(false) # false
 ```
 
 > **Note:** `Kind.of.<Type>` supports the to_proc protocol.
-> But it won't perform a strict validation, instead, it will return true
-> when the value has the desired kind and false if it hasn't.
+> And it will perform a strict validation as expected.
 
 ```ruby
 collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
-collection
-  .select(&Kind.of.Hash) # [{number: 1}, {number: 3}]
+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.
@@ -123,6 +130,24 @@ Kind.of.Boolean(nil, or: true) # true
 
 > **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.
 
 ```ruby
@@ -135,17 +160,24 @@ 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
 ```
 
 > **Note:** When `.instance?` is called without an argument,
@@ -155,27 +187,35 @@ Kind.of.Boolean.instance?(false) # true
 collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
 collection
-  .select(&Kind.of.Hash.instance?)
-  .reduce(0) { |total, item| total + item.fetch(:number, 0) } # 4
+  .select(&Kind.of.Hash.instance?) # [{:number=>1}, {:number=>3}]
 ```
 
-Also, there are aliases to perform the strict type verification. e.g:
+> **Note:** You can use a different syntax to perform an instance verification.
+> To do this, use Kind.of.\<Type\>?()
 
 ```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: {}] # {}
+Kind.of.Hash?({})                                # true
+Kind.of.Hash?({}, HashWithIndifferentAccess.new) # true
 
-# or
+Kind.of.Hash?('')     # false
+Kind.of.Hash?({}, '') # false
 
-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.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.
 
@@ -195,6 +235,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?
@@ -219,6 +302,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 #
 # ---------------------------------- #
@@ -257,7 +356,7 @@ end
 Kind.is(User, AdminUser) # true
 ```
 
-#### Registering new (custom) type checkers
+#### Registering new (custom) type checker
 
 Use `Kind::Types.add()`. e.g:
 
@@ -377,13 +476,165 @@ 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()`
 
 **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-)
+
 ## 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.
@@ -448,7 +699,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[], 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.
 
@@ -462,43 +733,70 @@ result =
 puts result # 42
 ```
 
-### Kind::Maybe#try
+You can also use `Kind::Maybe.wrap()` instead of the `.new` method.
 
-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
+result =
+  Kind::Maybe
+    .wrap(5)
+    .then { |value| value * 5 }
+    .then { |value| value + 17 }
+    .value_or(0)
+
+puts result # 42
+```
+
+#### 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[{}].try(:fetch, :number, 0) # 0
+# --
 
-p Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
+Kind::Maybe[a: 1, b: 2].then(&Add).value_or(0) # 3
 
-p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+# --
 
-#############
-# Nil value #
-#############
+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
+```
 
-object = nil
+### Kind::None() and Kind::Some()
 
-p Kind::Maybe[object].try(:upcase) # nil
+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:
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
+```ruby
+Add = -> params do
+  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
 
-#########################
-# Kind::Undefined value #
-#########################
+  return Kind::None unless Kind.of.Numeric?(a, b)
 
-object = Kind::Undefined
+  Kind::Some(a + b)
+end
 
-p Kind::Maybe[object].try(:upcase) # nil
+# --
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
-```
+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>
 
-[⬆️ Back to Top](#table-of-contents-)
+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()
 
@@ -555,6 +853,26 @@ result2 =
 puts result2 # 35
 ```
 
+#### 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-)
@@ -566,10 +884,11 @@ In these scenarios, you could check the given input type as optional and avoid u
 
 ```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::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"
@@ -590,9 +909,20 @@ def person_name(params)
     'John Doe'
   end
 end
+
+#
+# You can also use Kind::Optional(<Type>) to achieve the same behavior
+#
+def person_name(params)
+  Kind::Optional(Hash)
+    .wrap(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
 ```
 
-> 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).
+> 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.
 
@@ -666,136 +996,97 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
-## Kind::Validator (ActiveModel::Validations)
+### Kind::Maybe(<Type>)
 
-This module enables the capability to validate types via [active model validations](https://api.rubyonrails.org/classes/ActiveModel/Validations.html). e.g
+There is an alternative to `Kind.of.\<Type\>.as_optional`, you can use `Kind::Optional(<Type>)` to create a maybe monad which will return None if the given input hasn't the expected type. e.g:
 
 ```ruby
-class Person
-  include ActiveModel::Validations
-
-  attr_accessor :first_name, :last_name
+result1 =
+  Kind::Maybe(Numeric)
+    .wrap(5)
+    .then { |value| value * 5 }
+    .value_or { 0 }
 
-  validates :first_name, :last_name, kind: String
-end
-```
+puts result1 # 25
 
-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'
+result2 =
+  Kind::Optional(Numeric)
+    .wrap('5')
+    .then { |value| value * 5 }
+    .value_or { 0 }
 
-# In some .rb file
-require 'kind/active_model/validation'
+puts result2 # 0
 ```
 
-### Usage
-
-**[Object#kind_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-kind_of-3F)**
+This typed maybe has the same methods of `Kind::Maybe` class. e.g:
 
 ```ruby
-validates :name, kind: { of: String }
-# or
-validates :name, kind: { is_a: String }
+Kind::Maybe(Numeric)[5]
+Kind::Maybe(Numeric).new(5)
+Kind::Maybe(Numeric).wrap(5)
 
-# Use an array to verify if the attribute
-# is an instance of one of the classes/modules.
+# ---
 
-validates :status, kind: { of: [String, Symbol]}
-# or
-validates :status, kind: { is_a: [String, Symbol]}
+Kind::Optional(Numeric)[5]
+Kind::Optional(Numeric).new(5)
+Kind::Optional(Numeric).wrap(5)
 ```
 
-**[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] }
-```
+[⬆️ Back to Top](#table-of-contents-)
 
+### Kind::Maybe#try
 
-**[Object#respond_to?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-respond_to-3F)**
+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
-validates :handler, kind: { respond_to: :call }
-```
+object = 'foo'
 
-**Class == Class || Class < Class**
+Kind::Maybe[object].try(:upcase).value # "FOO"
 
-```ruby
-# Verifies if the attribute value is the class or a subclass.
+Kind::Maybe[{}].try(:fetch, :number, 0).value # 0
 
-validates :handler, kind: { klass: Handler }
+Kind::Maybe[{number: 1}].try(:fetch, :number).value # 1
 
-# or use the :is option
+Kind::Maybe[object].try { |value| value.upcase }.value # "FOO"
 
-validates :handler, kind: { is: Handler }
-```
+#############
+# Nil value #
+#############
 
-**Array.new.all? { |item| item.kind_of?(Class) }**
+object = nil
 
-```ruby
-validates :account_types, kind: { array_of: String }
+Kind::Maybe[object].try(:upcase).value # nil
 
-# or use an array to verify if the attribute
-# is an instance of one of the classes
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
 
-validates :account_types, kind: { array_of: [String, Symbol] }
-```
+#########################
+# Kind::Undefined value #
+#########################
 
-**Array.new.all? { |item| expected_values.include?(item) }**
+object = Kind::Undefined
 
-```ruby
-# Verifies if the attribute value
-# is an array with some or all the expected values.
+Kind::Maybe[object].try(:upcase).value # nil
 
-validates :account_types, kind: { array_with: ['foo', 'bar'] }
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
 ```
 
-#### Defining the default validation strategy
+> **Note:** You can use the `#try` method with `Kind::Optional` objects.
 
-By default, you can define the attribute type directly (without a hash). e.g.
+[⬆️ Back to Top](#table-of-contents-)
 
-```ruby
-validates :name, kind: String
-# or
-validates :name, kind: [String, Symbol]
-```
+### Kind::Maybe#try!
 
-To changes this behavior you can set another strategy to validates the attributes types:
+Has the same behavior of its `#try`, but it will raise an error if the value doesn't respond to the expected method.
 
 ```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:
--  `is_a`
--  `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.
+Kind::Maybe[{}].try(:upcase)  # => #<Kind::Maybe::None:0x0000... @value=nil>
 
-```ruby
-validates :name, kind: String, allow_nil: true
+Kind::Maybe[{}].try!(:upcase) # => NoMethodError (undefined method `upcase' for {}:Hash)
 ```
 
-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
-```
+> **Note:** You can also use the `#try!` method with `Kind::Optional` objects.
 
 [⬆️ Back to Top](#table-of-contents-)