kind 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a83d36b4c1fe131567251f418b775a8366ecf2a7c0d31682f801866cb9d83a27
-  data.tar.gz: b9b613500675aa1ea9e10c4b5ff83a451f289aec39896aaed025c196f0212ece
+  metadata.gz: 3bb8430c79ca97835ebdf6604e0c5afc4301f912db778e5f930fb9e699ae08c1
+  data.tar.gz: 0557c3df900513e5ec7d45fec79fdf7502f0cb06a8e1538ff935e0228ef11136
 SHA512:
-  metadata.gz: 252e2e4f3bd9bbd09ff182579d450de170688ada607dfaa30cd70748c1ac4473381c856ba1be37f74ccd1eb05d077763cbf853ea1f356c58226408108e69f4e8
-  data.tar.gz: f35a606761e6de74f81427a4431c711252303f78e4b0b5d11dd5e1878180112c1733fa4fef85949f3414196e387b54c672e768384f92aff9ac1c434662529834
+  metadata.gz: 0ad03f0d27484914f45607d9e1fd7cfdaf8000d700e31f069b274b5f977f42a8736a3d03d0cba1f3d06679f0f5a05b56d7c3b4acfd2a90cce20e524de6f9154a
+  data.tar.gz: 6f8e54590261939a43a52895921d80fb693a0e16361d011f53a80f1d7269aaade1e8871ae44374586ec488c026a02fced9057fdfcb300c532bd3a018498e954a

data/README.md

@@ -31,6 +31,10 @@ 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)
@@ -43,10 +47,6 @@ One of the goals of this project is to do simple type checking like `"some strin
     - [Replacing blocks by lambdas](#replacing-blocks-by-lambdas-2)
   - [Kind.of.\<Type\>.as_optional](#kindoftypeas_optional)
   - [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::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
@@ -163,13 +163,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 +192,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}]
@@ -459,6 +481,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.
@@ -586,7 +760,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
@@ -721,7 +895,7 @@ 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.
 
@@ -802,13 +976,13 @@ If you don't want to use a map to access the value, you could use the `#try` met
 ```ruby
 object = 'foo'
 
-p Kind::Maybe[object].try(:upcase) # "FOO"
+Kind::Maybe[object].try(:upcase) # "FOO"
 
-p Kind::Maybe[{}].try(:fetch, :number, 0) # 0
+Kind::Maybe[{}].try(:fetch, :number, 0) # 0
 
-p Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
+Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
 
-p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+Kind::Maybe[object].try { |value| value.upcase } # "FOO"
 
 #############
 # Nil value #
@@ -816,9 +990,9 @@ p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
 
 object = nil
 
-p Kind::Maybe[object].try(:upcase) # nil
+Kind::Maybe[object].try(:upcase) # nil
 
-p Kind::Maybe[object].try { |value| value.upcase } # nil
+Kind::Maybe[object].try { |value| value.upcase } # nil
 
 #########################
 # Kind::Undefined value #
@@ -826,162 +1000,12 @@ p Kind::Maybe[object].try { |value| value.upcase } # nil
 
 object = Kind::Undefined
 
-p Kind::Maybe[object].try(:upcase) # nil
-
-p Kind::Maybe[object].try { |value| value.upcase } # nil
-```
-
-[⬆️ 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.
+Kind::Maybe[object].try(:upcase) # nil
 
-```ruby
-validates :name, kind: String, allow_nil: true
+Kind::Maybe[object].try { |value| value.upcase } # 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 use the try method with the `Kind::Optional`.
 
 [⬆️ Back to Top](#table-of-contents-)
 

data/lib/kind.rb

@@ -18,9 +18,9 @@ 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
@@ -36,9 +36,9 @@ module Kind
   __checkers__
 
   def self.of(kind = Undefined, object = Undefined)
-    return Of if kind == Undefined && object == Undefined
+    return Of if Undefined == kind && Undefined == object
 
-    return Kind::Of.(kind, object) if object != Undefined
+    return Kind::Of.(kind, object) if Undefined != object
 
     __checkers__[kind] ||= begin
       kind_name = kind.name
@@ -65,7 +65,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,7 +81,7 @@ module Kind
     # -- Class
 
     def self.Class(object = Undefined)
-      return Class if object == Undefined
+      return Class if Undefined == object
 
       self.call(::Class, object)
     end
@@ -103,7 +103,7 @@ module Kind
     # -- Module
 
     def self.Module(object = Undefined)
-      return Module if object == Undefined
+      return Module if Undefined == object
 
       self.call(::Module, object)
     end
@@ -112,7 +112,7 @@ module Kind
       extend Checkable
 
       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 +137,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 +155,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
 
@@ -177,14 +177,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 +210,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
 
@@ -230,14 +230,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 +258,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
 
@@ -282,14 +282,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

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

@@ -11,7 +11,7 @@ module Kind
 
       return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
 
-      value != Kind::Undefined && instance?(value) ? value : Kind::Of.(__kind, default)
+      Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
     end
 
     def [](value, options = options = Empty::HASH)
@@ -38,7 +38,7 @@ module Kind
       return args.all? { |object| __is_instance__(object) } if args.size > 1
 
       arg = args[0]
-      arg == Kind::Undefined ? is_instance_to_proc : __is_instance__(arg)
+      Kind::Undefined == arg ? is_instance_to_proc : __is_instance__(arg)
     end
 
     def or_nil(value)
@@ -59,7 +59,7 @@ module Kind
     end
 
     def as_maybe(value = Kind::Undefined)
-      return __as_maybe__(value) if value != Kind::Undefined
+      return __as_maybe__(value) if Kind::Undefined != value
 
       as_maybe_to_proc
     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

@@ -4,7 +4,7 @@ module Kind
   module Maybe
     module Value
       def self.none?(value)
-        value == nil || value == Undefined
+        value.nil? || Undefined == value
       end
 
       def self.some?(value)
@@ -42,9 +42,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
@@ -56,7 +56,7 @@ module Kind
       alias_method :then, :map
 
       def try(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if method_name != Undefined
+        Kind.of.Symbol(method_name) if Undefined != method_name
 
         nil
       end
@@ -80,8 +80,8 @@ module Kind
         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
+        return NONE_WITH_NIL_VALUE if result.nil?
+        return NONE_WITH_UNDEFINED_VALUE if Undefined == result
 
         Some.new(result)
       end
@@ -89,7 +89,7 @@ module Kind
       alias_method :then, :map
 
       def try(method_name = Undefined, *args, &block)
-        fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
+        fn = Undefined == method_name ? block : Kind.of.Symbol(method_name).to_proc
 
         result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
 

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

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 = '2.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-12 00:00:00.000000000 Z
+date: 2020-06-23 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email: