kind 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebd68f3e676f6b030fa85da36b57a47a7f866e52373aed2b0e41315c63b0fdd0
-  data.tar.gz: 5800122e2ed54025450eabe06bee5f9df3474c45b6ffa396c3b80dc4ad8ca566
+  metadata.gz: a83d36b4c1fe131567251f418b775a8366ecf2a7c0d31682f801866cb9d83a27
+  data.tar.gz: b9b613500675aa1ea9e10c4b5ff83a451f289aec39896aaed025c196f0212ece
 SHA512:
-  metadata.gz: d3769fbbe39073a41961af28fde90412f30f1caab3b2129b4a91a39afb1e482310e209b1a5eea4249f09c667760f862c06cc98dc56ab7bb40854561ef75ea435
-  data.tar.gz: 8356c7a49afe6370ecced9485acd2a663d1f17729cbbccd89dec2c1f839ad0f754778502e447c89b8a129697a891bed07af30c20df0b52a9e4d338cb4df593ed
+  metadata.gz: 252e2e4f3bd9bbd09ff182579d450de170688ada607dfaa30cd70748c1ac4473381c856ba1be37f74ccd1eb05d077763cbf853ea1f356c58226408108e69f4e8
+  data.tar.gz: f35a606761e6de74f81427a4431c711252303f78e4b0b5d11dd5e1878180112c1733fa4fef85949f3414196e387b54c672e768384f92aff9ac1c434662529834

data/README.md

@@ -18,11 +18,14 @@ 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)
@@ -31,11 +34,15 @@ One of the goals of this project is to do simple type checking like `"some strin
 - [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[] and Kind::Maybe#then method aliases](#kindmaybe-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#try](#kindmaybetry)
 - [Kind::Validator (ActiveModel::Validations)](#kindvalidator-activemodelvalidations)
   - [Usage](#usage-1)
     - [Defining the default validation strategy](#defining-the-default-validation-strategy)
@@ -82,14 +89,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 +106,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 +128,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,11 +158,12 @@ 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?('') # false
 
 # ---
 
@@ -155,27 +179,19 @@ 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: {}] # {}
-
-# or
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
-Kind.of.Hash.instance(nil)  # raise Kind::Error, "nil expected to be a kind of Hash"
-Kind.of.Hash.instance('')   # raise Kind::Error, "'' expected to be a kind of Hash"
-Kind.of.Hash.instance(a: 1) # {a: 1}
-Kind.of.Hash.instance('', or: {}) # {}
+collection.select(&Kind.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.
 
@@ -262,6 +278,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 #
 # ---------------------------------- #
@@ -300,7 +332,7 @@ end
 Kind.is(User, AdminUser) # true
 ```
 
-#### Registering new (custom) type checkers
+#### Registering new (custom) type checker
 
 Use `Kind::Types.add()`. e.g:
 
@@ -491,7 +523,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[] 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.
 
@@ -505,43 +557,57 @@ result =
 puts result # 42
 ```
 
-### 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.
+#### 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.instance?(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()
 
@@ -598,6 +664,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-)
@@ -709,6 +795,44 @@ end
 
 [⬆️ 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'
+
+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"
+
+#############
+# Nil value #
+#############
+
+object = nil
+
+p Kind::Maybe[object].try(:upcase) # nil
+
+p Kind::Maybe[object].try { |value| value.upcase } # nil
+
+#########################
+# Kind::Undefined value #
+#########################
+
+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
@@ -839,7 +963,6 @@ Kind::Validator.default_strategy = :instance_of
 ```
 
 And these are the available options to define the default strategy:
--  `is_a`
 -  `kind_of` *(default)*
 -  `instance_of`
 

data/lib/kind.rb

@@ -29,6 +29,12 @@ module Kind
 
   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
 
@@ -45,8 +51,8 @@ module Kind
     end
   end
 
-  private_class_method def self.__checkers__
-    @__checkers__ ||= {}
+  def self.of?(kind, *args)
+    Kind.of(kind).instance?(*args)
   end
 
   # --------------------- #
@@ -90,6 +96,10 @@ module Kind
       def self.__is_instance__(value); class?(value); end
     end)
 
+    def self.Class?(*args)
+      Kind::Of::Class.instance?(*args)
+    end
+
     # -- Module
 
     def self.Module(object = Undefined)
@@ -136,6 +146,10 @@ module Kind
       def self.__is_instance__(value); class?(value); end
     end)
 
+    def self.Module?(*args)
+      Kind::Of::Module.instance?(*args)
+    end
+
     # -- Boolean
 
     def self.Boolean(object = Undefined, options = Empty::HASH)
@@ -187,6 +201,10 @@ module Kind
       end
     end)
 
+    def self.Boolean?(*args)
+      Kind::Of::Boolean.instance?(*args)
+    end
+
     # -- Lambda
 
     def self.Lambda(object = Undefined, options = Empty::HASH)
@@ -231,6 +249,10 @@ module Kind
       end
     end)
 
+    def self.Lambda?(*args)
+      Kind::Of::Lambda.instance?(*args)
+    end
+
     # -- Callable
 
     def self.Callable(object = Undefined, options = Empty::HASH)
@@ -279,6 +301,10 @@ module Kind
       end
     end)
 
+    def self.Callable?(*args)
+      Kind::Of::Callable.instance?(*args)
+    end
+
     # ---------------------- #
     # Built-in type checkers #
     # ---------------------- #

data/lib/kind/checker.rb

@@ -18,21 +18,29 @@ module Kind
       instance(value, options)
     end
 
-    def instance?(value = Kind::Undefined)
-      return __is_instance__(value) if value != Kind::Undefined
-
-      to_proc
+    def to_proc
+      @to_proc ||=
+        -> checker { -> value { checker.instance(value) } }.call(self)
     end
 
     def __is_instance__(value)
-      value.is_a?(__kind)
+      value.kind_of?(__kind)
     end
 
-    def to_proc
-      @to_proc ||=
+    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
@@ -41,6 +49,15 @@ module Kind
       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
 
@@ -50,15 +67,6 @@ module Kind
     def as_optional(value = Kind::Undefined)
       as_maybe(value)
     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
   end
 
   private_constant :Checkable

data/lib/kind/maybe.rb

@@ -16,7 +16,7 @@ module Kind
       attr_reader :value
 
       def initialize(value)
-        @value = value
+        @value = value.kind_of?(Result) ? value.value : value
       end
 
       def value_or(method_name = Undefined, &block)
@@ -44,7 +44,7 @@ module Kind
       def value_or(default = Undefined, &block)
         raise ArgumentError, INVALID_DEFAULT_ARG if default == Undefined && !block
 
-        Maybe::Value.some?(default) ? default : block.call
+        default != Undefined ? default : block.call
       end
 
       def none?; true; end
@@ -79,6 +79,7 @@ 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
 
@@ -98,13 +99,37 @@ module Kind
 
     def self.new(value)
       result_type = Maybe::Value.none?(value) ? None : Some
-      result_type.new(value.is_a?(Result) ? value.value : value)
+      result_type.new(value)
     end
 
     def self.[](value);
       new(value)
     end
+
+    def self.none
+      NONE_WITH_NIL_VALUE
+    end
+
+    VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
+
+    private_constant :VALUE_CANT_BE_NONE
+
+    def self.some(value)
+      return Maybe::Some.new(value) if Value.some?(value)
+
+      raise ArgumentError, VALUE_CANT_BE_NONE
+    end
   end
 
   Optional = Maybe
+
+  None = Maybe.none
+
+  def self.None
+    Kind::None
+  end
+
+  def self.Some(value)
+    Maybe.some(value)
+  end
 end

data/lib/kind/types.rb

@@ -12,7 +12,17 @@ module Kind
 
         return Kind::Of::%{kind_name} if object == Undefined && default.nil?
 
-        Kind::Of.(::%{kind_name_to_check}, (object || default))
+        is_instance = Kind::Of::%{kind_name}.__is_instance__(object)
+
+        return object if is_instance
+
+        Kind::Of.(::%{kind_name_to_check}, object && default ? default : object || default)
+      end
+    RUBY
+
+    KIND_OF_IS = <<-RUBY
+      def self.%{method_name}?(*args)
+        Kind::Of::%{kind_name}.instance?(*args)
       end
     RUBY
 
@@ -93,6 +103,7 @@ module Kind
 
           kind_of_mod.instance_eval(KIND_OF % params)
           kind_of_mod.const_set(method_name, kind_checker)
+          kind_of_mod.instance_eval(KIND_OF_IS % params)
         end
 
         unless kind_is_mod.respond_to?(method_name)

data/lib/kind/version.rb

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

metadata

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