kind 1.8.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0a88ddbce52eca41466b1c600f745b3c212e7833bbb178cabd86514e1011601
-  data.tar.gz: f96ab5843a3596a19863389dacda8e5865eff611163112f5092a3387ea6898a4
+  metadata.gz: a234e4c63dea23906a65da0718515bff19ac7934a3e919535596042cfd605bba
+  data.tar.gz: 5bcb0f1f669a0e87de070c5095cf8f769ddf97dde4b2169060fb21769ffbd623
 SHA512:
-  metadata.gz: 06af14f778ea084ae699a0c00e67d6808cbdace68a838cff42782fb7150f51e3524eba060784fd0cb540d08c2ecaa4b8135f75813e7d4223b87c9d1326831c05
-  data.tar.gz: 16e1e11bce9f67237a3f306b526f1b1f6564fe10eafcd22c2c90f2f18fa22077155a4372a9149d24dac02d266895e36c256a147a625f3592e8686bca974ab94b
+  metadata.gz: 232d87a65618b51c3ec8756ad9d08bce53a49d50368d4629c8e694050502dddf12cdecd878193e40e09c8fcc13139b1a35383eedaa36a1660f7cf71f7e4d9810
+  data.tar.gz: 4cef62a76d8981fa7409e0d598448b35b4bb01794084ad2ab264741cbf0a78e6b9142352369892e124f130750847078f90297e5d1eda955881ebea0f13e96ec7

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,7 +1,12 @@
 ---
 language: ruby
 
-cache: bundler
+sudo: false
+
+cache:
+  bundler: true
+  directories:
+    - /home/travis/.rvm/
 
 rvm:
   - 2.2.0
@@ -22,7 +27,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,48 @@
 
 # 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, exposing useful abstractions to do it.
+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[], 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)
-  - [Kind.of.<Type>.as_optional](#kindoftypeas_optional)
+    - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas-2)
+  - [Kind.of.\<Type\>.as_optional](#kindoftypeas_optional)
+  - [Kind::Maybe(<Type>)](#kindmaybetype)
+  - [Kind::Maybe#try](#kindmaybetry)
 - [Kind::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
@@ -78,14 +90,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}
 
 # ---
 
@@ -94,6 +106,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
@@ -106,7 +127,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.
 
@@ -120,51 +159,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
 ```
 
-**Note:** When `.instance?` is called without an argument, it will return a lambda which will perform the kind verification.
+> **Note:** When `.instance?` is called without an argument,
+> it will return a lambda which will perform the kind verification.
 
 ```ruby
-collection = [
-  {number: 1},
-  'number 0',
-  {number: 2},
-  [0],
-]
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
 collection
-  .select(&Kind.of.Hash.instance?)
-  .reduce(0) { |total, item| total + item.fetch(:number, 0) } # 3
+  .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.
 
@@ -184,6 +234,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?
@@ -208,6 +301,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 #
 # ---------------------------------- #
@@ -246,7 +355,7 @@ end
 Kind.is(User, AdminUser) # true
 ```
 
-#### Registering new (custom) type checkers
+#### Registering new (custom) type checker
 
 Use `Kind::Types.add()`. e.g:
 
@@ -366,13 +475,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.
@@ -437,7 +698,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.
 
@@ -451,43 +732,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()
 
@@ -544,11 +852,31 @@ 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-)
 
-### Kind.of.<Type>.as_optional
+### 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:
@@ -573,7 +901,7 @@ 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.is_a?(Hash) && params.values_at(:first_name, :last_name).compact.size == 2
+  if params.kind_of?(Hash) && params.values_at(:first_name, :last_name).compact.size == 2
     "#{params[:first_name]} #{params[:last_name]}"
   else
     'John Doe'
@@ -581,17 +909,12 @@ def person_name(params)
 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.
 
 ```ruby
-collection = [
-  {number: 1},
-  'number 0',
-  {number: 2},
-  [0],
-]
+collection = [ {number: 1}, 'number 0', {number: 2}, [0] ]
 
 collection
   .select(&Kind.of.Hash.as_optional)
@@ -613,9 +936,9 @@ module PersonIntroduction
   extend self
 
   def call(params)
-    optional_params = Kind::Of::Hash.as_optional(params)
+    optional = Kind::Of::Hash.as_optional(params)
 
-    "Hi my name is #{full_name(optional_params)}, I'm #{age(optional_params)} years old."
+    "Hi my name is #{full_name(optional)}, I'm #{age(optional)} years old."
   end
 
   private
@@ -637,7 +960,7 @@ module PersonIntroduction
   extend self
 
   def call(params)
-    "Hi my name is #{full_name(params)}, I'm #{age(params)}"
+    "Hi my name is #{full_name(params)}, I'm #{age(params)} years old."
   end
 
   private
@@ -660,6 +983,86 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
+### Kind::Maybe(<Type>)
+
+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
+result1 =
+  Kind::Maybe(Numeric)
+    .wrap(5)
+    .then { |value| value * 5 }
+    .value_or { 0 }
+
+puts result1 # 25
+
+# ---
+
+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)
+```
+
+[⬆️ 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-)
+
 ## Kind::Empty
 
 When you define a method that has default arguments, for certain data types, you will always create a new object in memory. e.g: