kind 2.1.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a83d36b4c1fe131567251f418b775a8366ecf2a7c0d31682f801866cb9d83a27
-  data.tar.gz: b9b613500675aa1ea9e10c4b5ff83a451f289aec39896aaed025c196f0212ece
+  metadata.gz: 7b62da87ad8443fb4d3f1d96535bc69259addf767721db70288401d677733967
+  data.tar.gz: 995f0a3a34ed67a3244e181380d627e076d4576a2b6e0c7de2b34fa415c5f868
 SHA512:
-  metadata.gz: 252e2e4f3bd9bbd09ff182579d450de170688ada607dfaa30cd70748c1ac4473381c856ba1be37f74ccd1eb05d077763cbf853ea1f356c58226408108e69f4e8
-  data.tar.gz: f35a606761e6de74f81427a4431c711252303f78e4b0b5d11dd5e1878180112c1733fa4fef85949f3414196e387b54c672e768384f92aff9ac1c434662529834
+  metadata.gz: 3398bbf2b67fe8b81023d9c781b14ac115f5749f45641a74fc1ff1c8d05f4fd1c4e2a4bc817d6c71e7f8dc96b245ec9f9c80a776ae11d22ba69dbc878dfaa847
+  data.tar.gz: 75c6c1e387548447edf601d4b73b18ff3e2700debf3f6715b2f772f582829d39a72e7bb9d8af61fe8bcd32e9f72aa8398f1703f2c706668a0ab5e59fc0612b05

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

@@ -31,22 +31,25 @@ One of the goals of this project is to do simple type checking like `"some strin
   - [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)
     - [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)
   - [Kind::Maybe#try](#kindmaybetry)
-- [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#try!](#kindmaybetry-1)
+  - [Kind::Maybe#dig](#kindmaybedig)
 - [Kind::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
@@ -163,13 +166,19 @@ Kind.of.Boolean.or_nil(true) # true
 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,
@@ -186,6 +195,22 @@ collection
 > To do this, use Kind.of.\<Type\>?()
 
 ```ruby
+Kind.of.Hash?({})                                # true
+Kind.of.Hash?({}, HashWithIndifferentAccess.new) # true
+
+Kind.of.Hash?('')     # false
+Kind.of.Hash?({}, '') # false
+
+# ---
+
+Kind.of.Boolean?(true)        # true
+Kind.of.Boolean?(false, true) # true
+
+Kind.of.Boolean?(nil)              # false
+Kind.of.Boolean?(false, true, nil) # false
+
+# ---
+
 collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
 collection.select(&Kind.of.Hash?) # [{:number=>1}, {:number=>3}]
@@ -434,6 +459,7 @@ The list of types (classes and modules) available to use with `Kind.of.*` or `Ki
 - `Kind.of.Range`
 - `Kind.of.Hash`
 - `Kind.of.Struct`
+- `Kind.of.OpenStruct`
 - `Kind.of.Enumerator`
 - `Kind.of.Set`
 - `Kind.of.Method`
@@ -459,6 +485,158 @@ The list of types (classes and modules) available to use with `Kind.of.*` or `Ki
 
 [⬆️ 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.
@@ -543,7 +721,7 @@ end
   Kind::Maybe.new(nil).map(&Add).value_or(0) # 0
 ```
 
-### Kind::Maybe[] and Kind::Maybe#then method aliases
+### 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.
 
@@ -557,6 +735,19 @@ 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
+```
+
 #### Replacing blocks by lambdas
 
 ```ruby
@@ -586,7 +777,7 @@ you could use the methods `Kind::None` and `Kind::Some` to do this. e.g:
 Add = -> params do
   a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)
 
-  return Kind::None unless Kind.of.Numeric.instance?(a, b)
+  return Kind::None unless Kind.of.Numeric?(a, b)
 
   Kind::Some(a + b)
 end
@@ -695,10 +886,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"
@@ -719,9 +911,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.
 
@@ -795,193 +998,162 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### Kind::Maybe#try
+### Kind::Maybe(<Type>)
 
-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.
+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
-object = 'foo'
-
-p Kind::Maybe[object].try(:upcase) # "FOO"
-
-p Kind::Maybe[{}].try(:fetch, :number, 0) # 0
-
-p Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
-
-p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+result1 =
+  Kind::Maybe(Numeric)
+    .wrap(5)
+    .then { |value| value * 5 }
+    .value_or { 0 }
 
-#############
-# Nil value #
-#############
+puts result1 # 25
 
-object = nil
+# ---
 
-p Kind::Maybe[object].try(:upcase) # nil
+result2 =
+  Kind::Optional(Numeric)
+    .wrap('5')
+    .then { |value| value * 5 }
+    .value_or { 0 }
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
+puts result2 # 0
+```
 
-#########################
-# Kind::Undefined value #
-#########################
+This typed maybe has the same methods of `Kind::Maybe` class. e.g:
 
-object = Kind::Undefined
+```ruby
+Kind::Maybe(Numeric)[5]
+Kind::Maybe(Numeric).new(5)
+Kind::Maybe(Numeric).wrap(5)
 
-p Kind::Maybe[object].try(:upcase) # nil
+# ---
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
+Kind::Optional(Numeric)[5]
+Kind::Optional(Numeric).new(5)
+Kind::Optional(Numeric).wrap(5)
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
 
-## Kind::Validator (ActiveModel::Validations)
+### Kind::Maybe#try
 
-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
+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
-class Person
-  include ActiveModel::Validations
-
-  attr_accessor :first_name, :last_name
-
-  validates :first_name, :last_name, kind: String
-end
-```
+object = 'foo'
 
-And to make use of it, you will need to do an explicitly require. e.g:
+Kind::Maybe[object].try(:upcase).value # "FOO"
 
-```ruby
-# In some Gemfile
-gem 'kind', require: 'kind/active_model/validation'
+Kind::Maybe[{}].try(:fetch, :number, 0).value # 0
 
-# In some .rb file
-require 'kind/active_model/validation'
-```
+Kind::Maybe[{number: 1}].try(:fetch, :number).value # 1
 
-### Usage
+Kind::Maybe[object].try { |value| value.upcase }.value # "FOO"
 
-**[Object#kind_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-kind_of-3F)**
-
-```ruby
-validates :name, kind: { of: String }
+#############
+# Nil value #
+#############
 
-# Use an array to verify if the attribute
-# is an instance of one of the classes/modules.
+object = nil
 
-validates :status, kind: { of: [String, Symbol]}
-```
+Kind::Maybe[object].try(:upcase).value # nil
 
-**[Kind.is](#verifying-the-kind-of-some-classmodule)**
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
 
-```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 }
+#########################
+# Kind::Undefined value #
+#########################
 
-#
-# 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
+object = Kind::Undefined
 
-validates :human_kind, kind: { is: Human }
+Kind::Maybe[object].try(:upcase).value # nil
 
-#
-# 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::Maybe[object].try { |value| value.upcase }.value # nil
+```
 
-validates :human_kind, kind: { is: Human }
+> **Note:** You can use the `#try` method with `Kind::Optional` objects.
 
-# or use an array to verify if the attribute
-# is a kind of one those classes/modules.
+[⬆️ Back to Top](#table-of-contents-)
 
-validates :human_kind, kind: { is: [Person, User] }
-```
+### Kind::Maybe#try!
 
-**[Object#instance_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-instance_of-3F)**
+Has the same behavior of its `#try`, but it will raise an error if the value doesn't respond to the expected method.
 
 ```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.
+Kind::Maybe[{}].try(:upcase)  # => #<Kind::Maybe::None:0x0000... @value=nil>
 
-validates :name, kind: { instance_of: [String, Symbol] }
+Kind::Maybe[{}].try!(:upcase) # => NoMethodError (undefined method `upcase' for {}:Hash)
 ```
 
+> **Note:** You can also use the `#try!` method with `Kind::Optional` objects.
 
-**[Object#respond_to?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-respond_to-3F)**
+[⬆️ Back to Top](#table-of-contents-)
 
-```ruby
-validates :handler, kind: { respond_to: :call }
-```
+### Kind::Maybe#dig
 
-**Array.new.all? { |item| item.kind_of?(Class) }**
+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
-validates :account_types, kind: { array_of: String }
-
-# or use an array to verify if the attribute
-# is an instance of one of the classes
+[nil, 1, '', /x/].each do |value|
+  p Kind::Maybe[value].dig(:foo).value # nil
+end
 
-validates :account_types, kind: { array_of: [String, Symbol] }
-```
+# --
 
-**Array.new.all? { |item| expected_values.include?(item) }**
+a = [1, 2, 3]
 
-```ruby
-# Verifies if the attribute value
-# is an array with some or all the expected values.
+Kind::Maybe[a].dig(0).value # 1
 
-validates :account_types, kind: { array_with: ['foo', 'bar'] }
-```
+Kind::Maybe[a].dig(3).value # nil
 
-#### Defining the default validation strategy
+# --
 
-By default, you can define the attribute type directly (without a hash). e.g.
+h = { foo: {bar: {baz: 1}}}
 
-```ruby
-validates :name, kind: String
-# or
-validates :name, kind: [String, Symbol]
-```
+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
 
-To changes this behavior you can set another strategy to validates the attributes types:
+Kind::Maybe[h].dig(:foo, :bar, 'baz').value # nil
 
-```ruby
-Kind::Validator.default_strategy = :instance_of
+# --
 
-# Tip: Create an initializer if you are in a Rails application.
-```
+i = { foo: [{'bar' => [1, 2]}, {baz: [3, 4]}] }
 
-And these are the available options to define the default strategy:
--  `kind_of` *(default)*
--  `instance_of`
+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
 
-#### Using the `allow_nil` and `strict` options
+Kind::Maybe[i].dig(:foo, 0, 'bar', 2).value # nil
 
-You can use the `allow_nil` option with any of the kind validations. e.g.
+# --
 
-```ruby
-validates :name, kind: String, allow_nil: true
+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
 ```
 
-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 `#dig` method with `Kind::Optional` objects.
 
 [⬆️ Back to Top](#table-of-contents-)
 

data/lib/kind.rb

@@ -2,14 +2,16 @@
 
 require 'kind/version'
 
+require 'ostruct'
+
 require 'kind/empty'
 require 'kind/undefined'
+require 'kind/checker'
 require 'kind/maybe'
 
 require 'kind/error'
 require 'kind/of'
 require 'kind/is'
-require 'kind/checker'
 require 'kind/types'
 
 module Kind
@@ -18,37 +20,19 @@ module Kind
   private_constant :WRONG_NUMBER_OF_ARGUMENTS
 
   def self.is(expected = Undefined, object = Undefined)
-    return Is if expected == Undefined && object == Undefined
+    return Is if Undefined == expected && Undefined == object
 
-    return Kind::Is.(expected, object) if object != Undefined
+    return Kind::Is.(expected, object) if Undefined != object
 
     raise ArgumentError, WRONG_NUMBER_OF_ARGUMENTS
   end
 
-  MODULE_OR_CLASS = 'Module/Class'.freeze
-
-  private_constant :MODULE_OR_CLASS
-
-  private_class_method def self.__checkers__
-    @__checkers__ ||= {}
-  end
-
-  __checkers__
-
   def self.of(kind = Undefined, object = Undefined)
-    return Of if kind == Undefined && object == Undefined
-
-    return Kind::Of.(kind, object) if object != Undefined
+    return Of if Undefined == kind && Undefined == object
 
-    __checkers__[kind] ||= begin
-      kind_name = kind.name
+    return Kind::Of.(kind, object) if Undefined != object
 
-      if Kind::Of.const_defined?(kind_name, false)
-        Kind::Of.const_get(kind_name)
-      else
-        Checker.new(Kind::Of.(Module, kind, MODULE_OR_CLASS))
-      end
-    end
+    Kind::Checker::Factory.create(kind)
   end
 
   def self.of?(kind, *args)
@@ -65,7 +49,7 @@ module Kind
     end
 
     def self.Module(value)
-      value == ::Module || (value.is_a?(::Module) && !self.Class(value))
+      ::Module == value || (value.is_a?(::Module) && !self.Class(value))
     end
 
     def self.Boolean(value)
@@ -81,13 +65,13 @@ module Kind
     # -- Class
 
     def self.Class(object = Undefined)
-      return Class if object == Undefined
+      return Class if Undefined == object
 
       self.call(::Class, object)
     end
 
     const_set(:Class, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; ::Class; end
 
@@ -103,16 +87,16 @@ module Kind
     # -- Module
 
     def self.Module(object = Undefined)
-      return Module if object == Undefined
+      return Module if Undefined == object
 
       self.call(::Module, object)
     end
 
     const_set(:Module, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind_undefined(value)
-        __kind_error(Kind::Undefined) if value == Kind::Undefined
+        __kind_error(Kind::Undefined) if Kind::Undefined == value
 
         yield
       end
@@ -137,7 +121,7 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { __kind_of(value) }
         else
-          return value if value != Kind::Undefined && instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { __kind_of(default) }
         end
@@ -155,7 +139,7 @@ module Kind
     def self.Boolean(object = Undefined, options = Empty::HASH)
       default = options[:or]
 
-      return Kind::Of::Boolean if object == Undefined && default.nil?
+      return Kind::Of::Boolean if Undefined == object && default.nil?
 
       bool = object.nil? ? default : object
 
@@ -165,7 +149,7 @@ module Kind
     end
 
     const_set(:Boolean, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; [TrueClass, FalseClass].freeze; end
 
@@ -177,14 +161,14 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Boolean(value) }
         else
-          return value if value != Kind::Undefined && instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Boolean(default) }
         end
       end
 
       def self.__kind_undefined(value)
-        if value == Kind::Undefined
+        if Kind::Undefined == value
           raise Kind::Error.new('Boolean'.freeze, Kind::Undefined)
         else
           yield
@@ -210,7 +194,7 @@ module Kind
     def self.Lambda(object = Undefined, options = Empty::HASH)
       default = options[:or]
 
-      return Kind::Of::Lambda if object == Undefined && default.nil?
+      return Kind::Of::Lambda if Undefined == object && default.nil?
 
       func = object || default
 
@@ -220,7 +204,7 @@ module Kind
     end
 
     const_set(:Lambda, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; ::Proc; end
 
@@ -230,14 +214,14 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Lambda(value) }
         else
-          return value if value != Kind::Undefined && instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Lambda(default) }
         end
       end
 
       def self.__kind_undefined(value)
-        if value == Kind::Undefined
+        if Kind::Undefined == value
           raise Kind::Error.new('Lambda'.freeze, Kind::Undefined)
         else
           yield
@@ -258,7 +242,7 @@ module Kind
     def self.Callable(object = Undefined, options = Empty::HASH)
       default = options[:or]
 
-      return Kind::Of::Callable if object == Undefined && default.nil?
+      return Kind::Of::Callable if Undefined == object && default.nil?
 
       callable = object || default
 
@@ -268,7 +252,7 @@ module Kind
     end
 
     const_set(:Callable, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; Object; end
 
@@ -282,14 +266,14 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Callable(value) }
         else
-          return value if value != Kind::Undefined && instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Callable(default) }
         end
       end
 
       def self.__kind_undefined(value)
-        if value == Kind::Undefined
+        if Kind::Undefined == value
           raise Kind::Error.new('Callable'.freeze, Kind::Undefined)
         else
           yield
@@ -312,7 +296,7 @@ module Kind
     # -- Classes
     [
       String, Symbol, Numeric, Integer, Float, Regexp, Time,
-      Array, Range, Hash, Struct, Enumerator, Set,
+      Array, Range, Hash, Struct, Enumerator, Set, OpenStruct,
       Method, Proc,
       IO, File
     ].each { |klass| Types.add(klass) }

data/lib/kind/active_model/kind_validator.rb

@@ -53,12 +53,12 @@ class KindValidator < ActiveModel::EachValidator
     def kind_is_not(expected, value)
       case expected
       when Class
-        return if Kind.of.Class(value) == expected || value < expected
+        return if expected == Kind.of.Class(value) || value < expected
 
         "must be the class or a subclass of `#{expected.name}`"
       when Module
         return if value.kind_of?(Class) && value <= expected
-        return if Kind.of.Module(value) == expected || value.kind_of?(expected)
+        return if expected == Kind.of.Module(value) || value.kind_of?(expected)
 
         "must include the `#{expected.name}` module"
       else

data/lib/kind/checker.rb

@@ -1,78 +1,10 @@
 # frozen_string_literal: true
 
+require 'kind/checker/factory'
+require 'kind/checker/protocol'
 module Kind
-  module Checkable
-    def class?(value)
-      Kind::Is.__call__(__kind, value)
-    end
-
-    def instance(value, options = Empty::HASH)
-      default = options[:or]
-
-      return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
-
-      value != Kind::Undefined && instance?(value) ? value : Kind::Of.(__kind, default)
-    end
-
-    def [](value, options = options = Empty::HASH)
-      instance(value, options)
-    end
-
-    def to_proc
-      @to_proc ||=
-        -> checker { -> value { checker.instance(value) } }.call(self)
-    end
-
-    def __is_instance__(value)
-      value.kind_of?(__kind)
-    end
-
-    def is_instance_to_proc
-      @is_instance_to_proc ||=
-        -> checker { -> value { checker.__is_instance__(value) } }.call(self)
-    end
-
-    def instance?(*args)
-      return is_instance_to_proc if args.empty?
-
-      return args.all? { |object| __is_instance__(object) } if args.size > 1
-
-      arg = args[0]
-      arg == Kind::Undefined ? is_instance_to_proc : __is_instance__(arg)
-    end
-
-    def or_nil(value)
-      return value if instance?(value)
-    end
-
-    def or_undefined(value)
-      or_nil(value) || Kind::Undefined
-    end
-
-    def __as_maybe__(value)
-      Kind::Maybe.new(or_nil(value))
-    end
-
-    def as_maybe_to_proc
-      @as_maybe_to_proc ||=
-        -> checker { -> value { checker.__as_maybe__(value) } }.call(self)
-    end
-
-    def as_maybe(value = Kind::Undefined)
-      return __as_maybe__(value) if value != Kind::Undefined
-
-      as_maybe_to_proc
-    end
-
-    def as_optional(value = Kind::Undefined)
-      as_maybe(value)
-    end
-  end
-
-  private_constant :Checkable
-
   class Checker
-    include Checkable
+    include Protocol
 
     attr_reader :__kind
 

data/lib/kind/checker/factory.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Kind
+  class Checker
+    class Factory
+      include Singleton
+
+      def self.create(kind)
+        instance.create(kind)
+      end
+
+      def initialize
+        @__checkers__ = {}
+      end
+
+      MODULE_OR_CLASS = 'Module/Class'.freeze
+
+      private_constant :MODULE_OR_CLASS
+
+      def create(kind)
+        @__checkers__[kind] ||= begin
+          kind_name = kind.name
+
+          if Kind::Of.const_defined?(kind_name, false)
+            Kind::Of.const_get(kind_name)
+          else
+            Kind::Checker.new(Kind::Of.(Module, kind, MODULE_OR_CLASS))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kind/checker/protocol.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Kind
+  class Checker
+    module Protocol
+      def class?(value)
+        Kind::Is.__call__(__kind, value)
+      end
+
+      def instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
+
+        Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
+      end
+
+      def [](value, options = options = Empty::HASH)
+        instance(value, options)
+      end
+
+      def to_proc
+        @to_proc ||=
+          -> checker { -> value { checker.instance(value) } }.call(self)
+      end
+
+      def __is_instance__(value)
+        value.kind_of?(__kind)
+      end
+
+      def is_instance_to_proc
+        @is_instance_to_proc ||=
+          -> checker { -> value { checker.__is_instance__(value) } }.call(self)
+      end
+
+      def instance?(*args)
+        return is_instance_to_proc if args.empty?
+
+        return args.all? { |object| __is_instance__(object) } if args.size > 1
+
+        arg = args[0]
+        Kind::Undefined == arg ? is_instance_to_proc : __is_instance__(arg)
+      end
+
+      def or_nil(value)
+        return value if instance?(value)
+      end
+
+      def or_undefined(value)
+        or_nil(value) || Kind::Undefined
+      end
+
+      def __as_maybe__(value)
+        Kind::Maybe.new(or_nil(value))
+      end
+
+      def as_maybe_to_proc
+        @as_maybe_to_proc ||=
+          -> checker { -> value { checker.__as_maybe__(value) } }.call(self)
+      end
+
+      def as_maybe(value = Kind::Undefined)
+        return __as_maybe__(value) if Kind::Undefined != value
+
+        as_maybe_to_proc
+      end
+
+      def as_optional(value = Kind::Undefined)
+        as_maybe(value)
+      end
+    end
+  end
+end

data/lib/kind/dig.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kind
+  module Dig
+    extend self
+
+    def call(data, keys)
+      return unless keys.is_a?(Array)
+
+      keys.reduce(data) do |memo, key|
+        value = get(memo, key)
+
+        break if value.nil?
+
+        value
+      end
+    end
+
+    private
+
+      def get(data, key)
+        return data[key] if Hash === data
+
+        case data
+        when Array
+          data[key] if key.respond_to?(:to_int)
+        when OpenStruct
+          data[key] if key.respond_to?(:to_sym)
+        when Struct
+          if key.respond_to?(:to_int) || key.respond_to?(:to_sym)
+            data[key] rescue nil
+          end
+        end
+      end
+  end
+end

data/lib/kind/error.rb

@@ -7,7 +7,7 @@ module Kind
     private_constant :UNDEFINED_OBJECT
 
     def initialize(arg, object = UNDEFINED_OBJECT)
-      if object == UNDEFINED_OBJECT
+      if UNDEFINED_OBJECT == object
         # Will be used when the exception was raised with a message. e.g:
         # raise Kind::Error, "some message"
         super(arg)

data/lib/kind/maybe.rb

@@ -1,10 +1,25 @@
 # frozen_string_literal: true
 
+require 'kind/dig'
+
 module Kind
   module Maybe
+    class Typed
+      def initialize(kind)
+        @kind_checker = Kind::Checker::Factory.create(kind)
+      end
+
+      def wrap(value)
+        @kind_checker.as_maybe(value)
+      end
+
+      alias_method :new, :wrap
+      alias_method :[], :wrap
+    end
+
     module Value
       def self.none?(value)
-        value == nil || value == Undefined
+        value.nil? || Undefined == value
       end
 
       def self.some?(value)
@@ -42,9 +57,9 @@ module Kind
       INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
 
       def value_or(default = Undefined, &block)
-        raise ArgumentError, INVALID_DEFAULT_ARG if default == Undefined && !block
+        raise ArgumentError, INVALID_DEFAULT_ARG if Undefined == default && !block
 
-        default != Undefined ? default : block.call
+        Undefined != default ? default : block.call
       end
 
       def none?; true; end
@@ -55,10 +70,16 @@ module Kind
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if method_name != Undefined
+      def try!(method_name = Undefined, *args, &block)
+        Kind.of.Symbol(method_name) if Undefined != method_name
 
-        nil
+        NONE_WITH_NIL_VALUE
+      end
+
+      alias_method :try, :try!
+
+      def dig(*keys)
+        NONE_WITH_NIL_VALUE
       end
 
       private_constant :INVALID_DEFAULT_ARG
@@ -79,22 +100,47 @@ module Kind
       def map(&fn)
         result = fn.call(@value)
 
-        return result if Maybe::None === result
-        return NONE_WITH_NIL_VALUE if result == nil
-        return NONE_WITH_UNDEFINED_VALUE if result == Undefined
-
-        Some.new(result)
+        resolve(result)
       end
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, *args, &block)
-        fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
+      def try!(method_name = Undefined, *args, &block)
+        Kind::Of::Symbol(method_name) if Undefined != method_name
+
+        __try__(method_name, args, block)
+      end
 
-        result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
+      def try(method_name = Undefined, *args, &block)
+        if (Undefined != method_name && value.respond_to?(Kind::Of::Symbol(method_name))) ||
+           (Undefined == method_name && block)
+          __try__(method_name, args, block)
+        else
+          NONE_WITH_NIL_VALUE
+        end
+      end
 
-        return result if Maybe::Value.some?(result)
+      def dig(*keys)
+        resolve(Kind::Dig.call(value, keys))
       end
+
+      private
+
+        def __try__(method_name = Undefined, args, block)
+          fn = Undefined == method_name ? block : method_name.to_proc
+
+          result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
+
+          resolve(result)
+        end
+
+        def resolve(result)
+          return result if Maybe::None === result
+          return NONE_WITH_NIL_VALUE if result.nil?
+          return NONE_WITH_UNDEFINED_VALUE if Undefined == result
+
+          Some.new(result)
+        end
     end
 
     def self.new(value)
@@ -102,7 +148,11 @@ module Kind
       result_type.new(value)
     end
 
-    def self.[](value);
+    def self.[](value)
+      new(value)
+    end
+
+    def self.wrap(value)
       new(value)
     end
 
@@ -132,4 +182,12 @@ module Kind
   def self.Some(value)
     Maybe.some(value)
   end
+
+  def self.Maybe(kind)
+    Maybe::Typed.new(kind)
+  end
+
+  def self.Optional(kind)
+    Maybe::Typed.new(kind)
+  end
 end

data/lib/kind/types.rb

@@ -10,7 +10,7 @@ module Kind
       def self.%{method_name}(object = Undefined, options = Empty::HASH)
         default = options[:or]
 
-        return Kind::Of::%{kind_name} if object == Undefined && default.nil?
+        return Kind::Of::%{kind_name} if Undefined == object && default.nil?
 
         is_instance = Kind::Of::%{kind_name}.__is_instance__(object)
 
@@ -28,7 +28,7 @@ module Kind
 
     KIND_IS = <<-RUBY
       def self.%{method_name}(value = Undefined)
-        return Kind::Is::%{kind_name} if value == Undefined
+        return Kind::Is::%{kind_name} if Undefined == value
 
         Kind::Is.__call__(::%{kind_name_to_check}, value)
       end
@@ -98,7 +98,7 @@ module Kind
           kind_name = params[:kind_name]
           params[:kind_name_to_check] ||= kind_name
 
-          kind_checker = ::Module.new { extend Checkable }
+          kind_checker = ::Module.new { extend Checker::Protocol }
           kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)

data/lib/kind/undefined.rb

@@ -19,7 +19,7 @@ module Kind
     end
 
     def undefined.default(value, default)
-      return self if value != self
+      return self if self != value
 
       default.respond_to?(:call) ? default.call : default
     end

data/lib/kind/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-12 00:00:00.000000000 Z
+date: 2020-07-08 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
@@ -32,6 +32,9 @@ files:
 - lib/kind/active_model/kind_validator.rb
 - lib/kind/active_model/validation.rb
 - lib/kind/checker.rb
+- lib/kind/checker/factory.rb
+- lib/kind/checker/protocol.rb
+- lib/kind/dig.rb
 - lib/kind/empty.rb
 - lib/kind/error.rb
 - lib/kind/is.rb