kind 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5426cb7f865320e961b1ad352dce372af3154afc520d1d9d4f64d7095ae0ddc2
-  data.tar.gz: b4ebb397ff928f49c2616b1464a964117b879c72ad37532381235d4e03e4d8f3
+  metadata.gz: 7dd5fb43e1dfd7c69d1a7ae3ffbf875769a675bbf7f8682bcfc9c8b3aa45c739
+  data.tar.gz: db15639b472a6b75d990b83f8b317ba7919f820b36e9a49a9141d387c6623768
 SHA512:
-  metadata.gz: 249dcd8cbb89239e035254ff28cffdd0d26a42e811fa86ae3682bf80d9ccf5154e129f1a5756e50ac4710db698361f0ab242d9018d3464384d72b7209d829bbe
-  data.tar.gz: 39723e362d309fddbd01b6732f962b60c361a29da36bf8ba73d9af65a2a579b750a98477c673d965bf3d81ef4cda60b215bf570d6aad00321bc44e497d997136
+  metadata.gz: fd548af2d4a1d93d5c4f2ef344318d35f140e1a7e4e82289897286ed6563004d7a8cc4577f94fb38b41e194c093ababf05e9d620b96a4ed420277dc94e154d87
+  data.tar.gz: 24ef063c68dc91f160b24a6d16992582cef56902b98bbc8fc54931c4e0076166f40c4795481e86e21cf546ae030f4c5aba49259785e8c00e46ab77debe374a27

data/README.md

@@ -21,16 +21,22 @@ One of the goals of this project is to do simple type checking like `"some strin
   - [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)
   - [How to create a new type checker?](#how-to-create-a-new-type-checker)
-    - [What happens if a custom type checker has a namespace?](#what-happens-if-a-custom-type-checker-has-a-namespace)
-- [Built-in type checkers](#built-in-type-checkers)
+    - [Creating/Verifiyng type checkers dynamically](#creatingverifiyng-type-checkers-dynamically)
+    - [Registering new (custom) type checkers](#registering-new-custom-type-checkers)
+      - [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 checker](#classes-type-checker)
+  - [Module type checkers](#module-type-checkers)
   - [Special type checkers](#special-type-checkers)
     - [Kind.of](#kindof)
-    - [Kind.is](#kindis)
 - [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)
+  - [Kind.of.Maybe()](#kindofmaybe)
   - [Kind::Optional](#kindoptional)
+  - [Kind::Empty](#kindempty)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -77,15 +83,12 @@ By default, basic verifications are strict. So, when you perform `Kind.of.Hash(v
 
 ```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.Boolean(nil)   # raise Kind::Error, "nil expected to be a kind of Boolean"
-
 Kind.of.Boolean(true)  # true
 Kind.of.Boolean(false) # false
 ```
@@ -107,11 +110,8 @@ As an alternative syntax, you can use the `Kind::Of` instead of the method. e.g:
 But if you don't need a strict type verification, use the `.or_nil`method
 
 ```ruby
-Kind.of.Hash.or_nil('')
-# nil
-
-Kind.of.Hash.or_nil({a: 1})
-# {a: 1}
+Kind.of.Hash.or_nil('')     # nil
+Kind.of.Hash.or_nil({a: 1}) # {a: 1}
 
 # ---
 
@@ -132,6 +132,22 @@ Kind.of.Boolean.instance?(true)  # true
 Kind.of.Boolean.instance?(false) # true
 ```
 
+Also, there are aliases to perform the strict type verification. e.g:
+
+```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: {}) # {}
+```
+
 ### Verifying the kind of some class/module
 
 You can use `Kind.is` to verify if some class has the expected type as its ancestor.
@@ -156,6 +172,57 @@ Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess) # true
 
 ### How to create a new type checker?
 
+There are two ways to do this, you can create type checkers dynamically or register new ones.
+
+#### Creating/Verifiyng type checkers dynamically
+
+```ruby
+class User
+end
+
+user = User.new
+
+# ------------------------ #
+# Verifiyng the value kind #
+# ------------------------ #
+
+Kind.of(User, user) # <User ...>
+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)
+
+# ---------------------------------- #
+# Creating type checkers dynamically #
+# ---------------------------------- #
+
+kind_of_user = Kind.of(User)
+
+kind_of_user.or_nil({}) # nil
+
+kind_of_user.instance?({})   # false
+kind_of_user.instance?(User) # true
+
+kind_of_user.class?(Hash)  # false
+kind_of_user.class?(User)  # true
+
+# Create type checkers dynamically is cheap
+# because of a singleton object is created to be available for use.
+
+kind_of_user.object_id == Kind.of(User).object_id # true
+
+# --------------------------------------------- #
+# Kind.is() can be used to check a class/module #
+# --------------------------------------------- #
+
+class Admin < User
+end
+
+Kind.is(Admin, User) # true
+```
+
+#### Registering new (custom) type checkers
+
 Use `Kind::Types.add()`. e.g:
 
 ```ruby
@@ -191,7 +258,7 @@ Kind.of.User.class?(User)  # true
 
 [⬆️ Back to Top](#table-of-contents-)
 
-#### What happens if a custom type checker has a namespace?
+##### What happens if a custom type checker has a namespace?
 
 The type checker will preserve the namespace. ;)
 
@@ -210,57 +277,63 @@ module Account
   end
 end
 
-Kind.of.Account::User(Account::User.new)  # #<Account::User:0x0000...>
+Kind.of.Account::User({}) # Kind::Error ({} expected to be a kind of Account::User)
 
-Kind.of.Account::User({})        # Kind::Error ({} expected to be a kind of Account::User)
+Kind.of.Account::User(Account::User.new)  # #<Account::User:0x0000...>
 
 Kind.of.Account::User.or_nil({}) # nil
 
-Kind.of.Account::User.instance?({})   # false
-Kind.of.Account::User.instance?(User) # true
+Kind.of.Account::User.instance?({})                # false
+Kind.of.Account::User.instance?(Account::User.new) # true
 
-Kind.of.Account::User.class?(Hash)  # false
-Kind.of.Account::User.class?(User)  # true
+Kind.of.Account::User.class?(Hash)           # false
+Kind.of.Account::User.class?(Account::User)  # true
 
 # ---
 
-Kind.of.Account::User::Membership(Account::User::Membership.new)  # #<Account::User::Membership:0x0000...>
+Kind.of.Account::User::Membership({}) # Kind::Error ({} expected to be a kind of Account::User::Membership)
 
-Kind.of.Account::User::Membership({})        # Kind::Error ({} expected to be a kind of Account::User::Membership)
+Kind.of.Account::User::Membership(Account::User::Membership.new)  # #<Account::User::Membership:0x0000...>
 
 Kind.of.Account::User::Membership.or_nil({}) # nil
 
-Kind.of.Account::User::Membership.instance?({})   # false
-Kind.of.Account::User::Membership.instance?(User) # true
+Kind.of.Account::User::Membership.instance?({})                            # false
+Kind.of.Account::User::Membership.instance?(Account::User::Membership.new) # true
 
-Kind.of.Account::User::Membership.class?(Hash)  # false
-Kind.of.Account::User::Membership.class?(User)  # true
+Kind.of.Account::User::Membership.class?(Hash)                      # false
+Kind.of.Account::User::Membership.class?(Account::User::Membership) # true
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
 
-## Built-in type checkers
+## Type checkers
 
 The list of types (classes and modules) available to use with `Kind.of.*` or `Kind.is.*` are:
 
-| Classes    | Modules    |
-| ---------- | ---------- |
-| String     | Enumerable |
-| Symbol     | Comparable |
-| Numeric    |            |
-| Integer    |            |
-| Float      |            |
-| Regexp     |            |
-| Time       |            |
-| Array      |            |
-| Range      |            |
-| Hash       |            |
-| Struct     |            |
-| Enumerator |            |
-| Method     |            |
-| Proc       |            |
-| IO         |            |
-| File       |            |
+## Classes' type checker
+
+- `Kind.of.String`
+- `Kind.of.Symbol`
+- `Kind.of.Numeric`
+- `Kind.of.Integer`
+- `Kind.of.Float`
+- `Kind.of.Regexp`
+- `Kind.of.Time`
+- `Kind.of.Array`
+- `Kind.of.Range`
+- `Kind.of.Hash`
+- `Kind.of.Struct`
+- `Kind.of.Enumerator`
+- `Kind.of.Set`
+- `Kind.of.Method`
+- `Kind.of.Proc`
+- `Kind.of.IO`
+- `Kind.of.File`
+
+### Module type checkers
+
+- `Kind.of.Enumerable`
+- `Kind.of.Comparable`
 
 ### Special type checkers
 
@@ -270,14 +343,10 @@ 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()`
-
-#### Kind.is
+- `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.Maybe()` or its alias `Kind.of.Optional()`
 
-- `Kind.is.Class()`
-- `Kind.is.Module()`
-- `Kind.is.Boolean()`
-- `Kind.is.Callable()`: verifies if the given value `respond_to?(:call)` or if it's a class/module and if its `public_instance_methods.include?(:call)`.
+PS: 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-)
 
@@ -287,6 +356,15 @@ The [`Kind::Undefined`](https://github.com/serradura/kind/blob/834f6b8ebdc737de8
 
 If you are interested, check out [the tests](https://github.com/serradura/kind/blob/834f6b8ebdc737de8e5628986585f30c1a5aa41b/test/kind/undefined_test.rb) to understand its methods.
 
+### Kind.of.<Type>.or_undefined()
+
+If you interested in use `Kind::Undefined` you can use the method `.or_undefined` with any of the [available type checkers](#type-checkers). e.g:
+
+```ruby
+Kind.of.String.or_undefined(nil)         # Kind::Undefined
+Kind.of.String.or_undefined("something") # "something"
+```
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ## Kind::Maybe
@@ -384,6 +462,36 @@ p Kind::Maybe[object].try { |value| value.upcase } # nil
 
 [⬆️ Back to Top](#table-of-contents-)
 
+### Kind.of.Maybe()
+
+You can use the `Kind.of.Maybe()` to know if the given value is a kind of `Kind::Maybe`object. e.g:
+
+```ruby
+def double(maybe_number)
+  Kind.of.Maybe(maybe_number)
+    .map { |value| value * 2 }
+    .value_or(0)
+end
+
+number = Kind::Maybe[4]
+
+puts double(number) # 8
+
+# -------------------------------------------------------#
+# All the type checker methods are available to use too. #
+# -------------------------------------------------------#
+
+Kind.of.Maybe.instance?(number) # true
+
+Kind.of.Maybe.or_nil(number) # <Kind::Maybe::Some @value=4 ...>
+
+Kind.of.Maybe.instance(number) # <Kind::Maybe::Some @value=4 ...>
+Kind.of.Maybe.instance(4) # Kind::Error (4 expected to be a kind of Kind::Maybe::Result)
+
+Kind.of.Maybe[number] # <Kind::Maybe::Some @value=4 ...>
+Kind.of.Maybe[4] # Kind::Error (4 expected to be a kind of Kind::Maybe::Result)
+```
+
 ### Kind::Optional
 
 The `Kind::Optional` constant is an alias for `Kind::Maybe`. e.g:
@@ -409,6 +517,55 @@ result2 =
 puts result2 # 35
 ```
 
+PS: The `Kind.of.Optional` is available to check if some value is a `Kind::Optional`.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Kind::Empty
+
+There is a common need to define default argument values. In case you don't know, depending on the argument data type, when a  method is invoked a new object will be created in the program memory to fills some default argument value. e.g:
+
+```ruby
+def something(params = {})
+  params.object_id
+end
+
+puts something # 70312470300460
+puts something # 70312470295800
+puts something # 70312470278400
+puts something # 70312470273800
+```
+
+So, to avoid an unnecessary allocation in memory, the `kind` gem exposes some frozen objects to be used as default values.
+
+- `Kind::Empty::SET`
+- `Kind::Empty::HASH`
+- `Kind::Empty::ARRAY`
+- `Kind::Empty::STRING`
+
+Usage example:
+
+```ruby
+def do_something(value, with_options: Kind::Empty::HASH)
+  # ...
+end
+```
+
+One last thing, if there is no constant declared as Empty, the `kind` gem will define `Empty` as an alias for `Kind::Empty`. Knowing this, the previous example could be written like this:
+
+```ruby
+def do_something(value, with_options: Empty::HASH)
+  # ...
+end
+```
+
+Follows the list of constants, if the alias is available to be created:
+
+- `Empty::SET`
+- `Empty::HASH`
+- `Empty::ARRAY`
+- `Empty::STRING`
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ## Development

data/lib/kind.rb

@@ -1,38 +1,67 @@
 # frozen_string_literal: true
 
 require 'kind/version'
+
+require 'kind/empty'
 require 'kind/undefined'
 require 'kind/maybe'
+
 require 'kind/error'
+require 'kind/of'
 require 'kind/is'
 require 'kind/checker'
-require 'kind/of'
 require 'kind/types'
 
 module Kind
-  def self.is; Is; end
-  def self.of; Of; end
+  WRONG_NUMBER_OF_ARGUMENTS = 'wrong number of arguments (given 1, expected 2)'.freeze
+
+  private_constant :WRONG_NUMBER_OF_ARGUMENTS
+
+  def self.is(expected = Undefined, object = Undefined)
+    return Is if expected == Undefined && object == Undefined
+
+    return Kind::Is.(expected, object) if object != Undefined
+
+    raise ArgumentError, WRONG_NUMBER_OF_ARGUMENTS
+  end
+
+  MODULE_OR_CLASS = 'Module/Class'.freeze
 
-  # -- Classes
-  [
-    String, Symbol, Numeric, Integer, Float, Regexp, Time,
-    Array, Range, Hash, Struct, Enumerator,
-    Method, Proc,
-    IO, File
-  ].each { |klass| Types.add(klass) }
+  private_constant :MODULE_OR_CLASS
 
-  Types.add(Queue, name: 'Queue'.freeze)
+  def self.of(kind = Undefined, object = Undefined)
+    return Of if kind == Undefined && object == Undefined
 
-  # -- Modules
-  [
-    Enumerable, Comparable
-  ].each { |klass| Types.add(klass) }
+    return Kind::Of.(kind, object) if object != Undefined
+
+    __checkers__[kind] ||= begin
+      kind_name = kind.name
+
+      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
+  end
+
+  private_class_method def self.__checkers__
+    @__checkers__ ||= {}
+  end
 
   # --------------------- #
   # Special type checkers #
   # --------------------- #
 
   module Is
+    def self.Class(value)
+      value.is_a?(::Class)
+    end
+
+    def self.Module(value)
+      value == ::Module || (value.is_a?(::Module) && !self.Class(value))
+    end
+
     def self.Boolean(value)
       klass = Kind.of.Class(value)
       klass <= TrueClass || klass <= FalseClass
@@ -44,9 +73,73 @@ module Kind
   end
 
   module Of
+    # -- Class
+
+    def self.Class(object = Undefined)
+      return Class if object == Undefined
+
+      self.call(::Class, object)
+    end
+
+    const_set(:Class, ::Module.new do
+      extend Checkable
+
+      def self.__kind; ::Class; end
+
+      def self.class?(value); Kind::Is.Class(value); end
+
+      def self.instance?(value); class?(value); end
+    end)
+
+    # -- Module
+
+    def self.Module(object = Undefined)
+      return Module if object == Undefined
+
+      self.call(::Module, object)
+    end
+
+    const_set(:Module, ::Module.new do
+      extend Checkable
+
+      def self.__kind; ::Module; end
+
+      def self.__kind_error(value)
+        raise Kind::Error.new('Module'.freeze, value)
+      end
+
+      def self.__kind_of(value)
+        return value if Kind::Is.Module(value)
+
+        __kind_error(value)
+      end
+
+      def self.__kind_undefined(value)
+        __kind_error(Kind::Undefined) if value == Kind::Undefined
+
+        yield
+      end
+
+      def self.class?(value); Kind::Is.Module(value); end
+
+      def self.instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::Maybe::Value.none?(default)
+          __kind_undefined(value) { __kind_of(value) }
+        else
+          return value if instance?(value)
+
+          __kind_undefined(default) { __kind_of(default) }
+        end
+      end
+
+      def self.instance?(value); class?(value); end
+    end)
+
     # -- Boolean
 
-    def self.Boolean(object = Undefined, options = {})
+    def self.Boolean(object = Undefined, options = Empty::HASH)
       default = options[:or]
 
       return Kind::Of::Boolean if object == Undefined && default.nil?
@@ -59,20 +152,45 @@ module Kind
     end
 
     const_set(:Boolean, ::Module.new do
-      extend Checker
+      extend Checkable
 
       def self.__kind; [TrueClass, FalseClass].freeze; end
 
       def self.class?(value); Kind.is.Boolean(value); end
 
+      def self.instance(value, options= Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::Maybe::Value.none?(default)
+          __kind_undefined(value) { Kind::Of::Boolean(value) }
+        else
+          return value if instance?(value)
+
+          __kind_undefined(default) { Kind::Of::Boolean(default) }
+        end
+      end
+
+      def self.__kind_undefined(value)
+        if value == Kind::Undefined
+          raise Kind::Error.new('Boolean'.freeze, Kind::Undefined)
+        else
+          yield
+        end
+      end
+
       def self.instance?(value);
         value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
+
+      def self.or_undefined(value)
+        result = or_nil(value)
+        result.nil? ? Kind::Undefined : result
+      end
     end)
 
     # -- Lambda
 
-    def self.Lambda(object = Undefined, options = {})
+    def self.Lambda(object = Undefined, options = Empty::HASH)
       default = options[:or]
 
       return Kind::Of::Lambda if object == Undefined && default.nil?
@@ -85,10 +203,30 @@ module Kind
     end
 
     const_set(:Lambda, ::Module.new do
-      extend Checker
+      extend Checkable
 
       def self.__kind; ::Proc; end
 
+      def self.instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::Maybe::Value.none?(default)
+          __kind_undefined(value) { Kind::Of::Lambda(value) }
+        else
+          return value if instance?(value)
+
+          __kind_undefined(default) { Kind::Of::Lambda(default) }
+        end
+      end
+
+      def self.__kind_undefined(value)
+        if value == Kind::Undefined
+          raise Kind::Error.new('Lambda'.freeze, Kind::Undefined)
+        else
+          yield
+        end
+      end
+
       def self.instance?(value)
         value.is_a?(__kind) && value.lambda?
       end
@@ -96,7 +234,7 @@ module Kind
 
     # -- Callable
 
-    def self.Callable(object = Undefined, options = {})
+    def self.Callable(object = Undefined, options = Empty::HASH)
       default = options[:or]
 
       return Kind::Of::Callable if object == Undefined && default.nil?
@@ -109,7 +247,7 @@ module Kind
     end
 
     const_set(:Callable, ::Module.new do
-      extend Checker
+      extend Checkable
 
       def self.__kind; Object; end
 
@@ -117,9 +255,53 @@ module Kind
         Kind::Is::Callable(value)
       end
 
+      def self.instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::Maybe::Value.none?(default)
+          __kind_undefined(value) { Kind::Of::Callable(value) }
+        else
+          return value if instance?(value)
+
+          __kind_undefined(default) { Kind::Of::Callable(default) }
+        end
+      end
+
+      def self.__kind_undefined(value)
+        if value == Kind::Undefined
+          raise Kind::Error.new('Callable'.freeze, Kind::Undefined)
+        else
+          yield
+        end
+      end
+
       def self.instance?(value);
         value.respond_to?(:call)
       end
     end)
+
+    # ---------------------- #
+    # Built-in type checkers #
+    # ---------------------- #
+
+    # -- Classes
+    [
+      String, Symbol, Numeric, Integer, Float, Regexp, Time,
+      Array, Range, Hash, Struct, Enumerator, Set,
+      Method, Proc,
+      IO, File
+    ].each { |klass| Types.add(klass) }
+
+    Types.add(Queue, name: 'Queue'.freeze)
+
+    # -- Modules
+    [
+      Enumerable, Comparable
+    ].each { |klass| Types.add(klass) }
+
+    # -- Kind::Of::Maybe
+
+    Types.add(Kind::Maybe::Result, name: 'Maybe'.freeze)
+    Types.add(Kind::Maybe::Result, name: 'Optional'.freeze)
   end
 end

data/lib/kind/checker.rb

@@ -1,9 +1,21 @@
 # frozen_string_literal: true
 
 module Kind
-  module Checker
+  module Checkable
     def class?(value)
-      Kind::Is.(__kind, 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)
+
+      instance?(value) ? value : Kind::Of.(__kind, default)
+    end
+
+    def [](value, options = options = Empty::HASH)
+      instance(value, options)
     end
 
     def instance?(value)
@@ -13,7 +25,21 @@ module Kind
     def or_nil(value)
       return value if instance?(value)
     end
+
+    def or_undefined(value)
+      or_nil(value) || Kind::Undefined
+    end
   end
 
-  private_constant :Checker
+  private_constant :Checkable
+
+  class Checker
+    include Checkable
+
+    attr_reader :__kind
+
+    def initialize(kind)
+      @__kind = kind
+    end
+  end
 end

data/lib/kind/empty.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Kind
+  module Empty
+    SET = ::Set.new.freeze
+
+    HASH = {}.freeze
+
+    ARY = [].freeze
+    ARRAY = ARY
+
+    STR = ''.freeze
+    STRING = STR
+  end
+end
+
+unless defined?(Empty)
+  Empty = Kind::Empty
+end

data/lib/kind/error.rb

@@ -2,8 +2,8 @@
 
 module Kind
   class Error < TypeError
-    def initialize(klass, object)
-      super("#{object.inspect} expected to be a kind of #{klass}")
+    def initialize(kind_name, object)
+      super("#{object.inspect} expected to be a kind of #{kind_name}")
     end
   end
 end

data/lib/kind/is.rb

@@ -2,19 +2,14 @@
 
 module Kind
   module Is
-    def self.call(expected, value)
-      expected_mod = Kind::Of.Module(expected)
-      mod = Kind::Of.Module(value)
-
-      mod <= expected_mod || false
+    def self.call(expected, object)
+      __call__(Kind::Of.Module(expected), object)
     end
 
-    def self.Class(value)
-      value.is_a?(::Class)
-    end
+    def self.__call__(expected_kind, object)
+      kind = Kind::Of.Module(object)
 
-    def self.Module(value)
-      value == ::Module || (value.is_a?(::Module) && !self.Class(value))
+      kind <= expected_kind || false
     end
   end
 end

data/lib/kind/maybe.rb

@@ -19,19 +19,25 @@ module Kind
         @value = value
       end
 
-      def value_or(default, &block); end
+      def value_or(method_name = Undefined, &block)
+        raise NotImplementedError
+      end
 
-      def none?; end
+      def none?
+        raise NotImplementedError
+      end
 
       def some?; !none?; end
 
-      def map(&fn); end
+      def map(&fn)
+        raise NotImplementedError
+      end
 
-      def try(method_name, &block); end
+      def try(method_name = Undefined, &block)
+        raise NotImplementedError
+      end
     end
 
-    private_constant :Result
-
     class None < Result
       INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
 

data/lib/kind/of.rb

@@ -2,42 +2,10 @@
 
 module Kind
   module Of
-    def self.call(klass, object, name: nil)
-      return object if object.is_a?(klass)
+    def self.call(kind, object, kind_name = nil)
+      return object if kind === object
 
-      raise Kind::Error.new((name || klass.name), object)
+      raise Kind::Error.new(kind_name || kind.name, object)
     end
-
-    def self.Class(object = Undefined)
-      return Class if object == Undefined
-
-      self.call(::Class, object)
-    end
-
-    const_set(:Class, ::Module.new do
-      extend Checker
-
-      def self.__kind; ::Class; end
-
-      def self.class?(value); Kind::Is.Class(value); end
-
-      def self.instance?(value); class?(value); end
-    end)
-
-    def self.Module(object = Undefined)
-      return Module if object == Undefined
-
-      self.call(::Module, object)
-    end
-
-    const_set(:Module, ::Module.new do
-      extend Checker
-
-      def self.__kind; ::Module; end
-
-      def self.class?(value); Kind::Is.Module(value); end
-
-      def self.instance?(value); class?(value); end
-    end)
   end
 end

data/lib/kind/types.rb

@@ -7,12 +7,12 @@ module Kind
     COLONS = '::'.freeze
 
     KIND_OF = <<-RUBY
-      def self.%{method_name}(object = Undefined, options = {})
+      def self.%{method_name}(object = Undefined, options = Empty::HASH)
         default = options[:or]
 
         return Kind::Of::%{kind_name} if object == Undefined && default.nil?
 
-        Kind::Of.(::%{kind_name}, (object || default), name: "%{kind_name}".freeze)
+        Kind::Of.(::%{kind_name_to_check}, (object || default))
       end
     RUBY
 
@@ -20,7 +20,7 @@ module Kind
       def self.%{method_name}(value = Undefined)
         return Kind::Is::%{kind_name} if value == Undefined
 
-        Kind::Is.(::%{kind_name}, value)
+        Kind::Is.__call__(::%{kind_name_to_check}, value)
       end
     RUBY
 
@@ -30,21 +30,27 @@ module Kind
       kind_name = Kind.of.Module(kind).name
       checker = name ? Kind::Of.(String, name) : kind_name
 
-      case
-      when checker.include?(COLONS)
+      if checker.include?(COLONS)
         add_kind_with_namespace(checker, method_name: name)
       else
-        add_root(checker, kind_name, method_name: name, create_kind_is_mod: false)
+        add_root(checker, kind_name, method_name: name,
+                                     kind_name_to_check: kind_name,
+                                     create_kind_is_mod: false)
       end
     end
 
     private
 
-      def add_root(checker, kind_name, method_name:, create_kind_is_mod:)
-        root_checker = method_name ? method_name : checker
+      def add_root(checker, kind_name, method_name:, create_kind_is_mod:, kind_name_to_check: nil)
         root_kind_name = method_name ? method_name : kind_name
 
-        add_kind(root_checker, root_kind_name, Kind::Of, Kind::Is, create_kind_is_mod)
+        params = {
+          method_name: method_name ? method_name : checker,
+          kind_name: method_name ? method_name : kind_name,
+          kind_name_to_check: kind_name_to_check || root_kind_name
+        }
+
+        add_kind(params, Kind::Of, Kind::Is, create_kind_is_mod)
       end
 
       def add_kind_with_namespace(checker, method_name:)
@@ -70,23 +76,28 @@ module Kind
         checker = const_names[index]
         kind_name = const_names[0..index].join(COLONS)
 
-        add_kind(checker, kind_name, kind_of_mod, kind_is_mod, true)
+        params = { method_name: checker, kind_name: kind_name }
+
+        add_kind(params, kind_of_mod, kind_is_mod, true)
       end
 
-      def add_kind(checker, kind_name, kind_of_mod, kind_is_mod, create_kind_is_mod)
-        params = { method_name: checker, kind_name: kind_name }
+      def add_kind(params, kind_of_mod, kind_is_mod, create_kind_is_mod)
+        method_name = params[:method_name]
+
+        unless kind_of_mod.respond_to?(method_name)
+          kind_name = params[:kind_name]
+          params[:kind_name_to_check] ||= kind_name
 
-        unless kind_of_mod.respond_to?(checker)
-          kind_checker = ::Module.new { extend Checker }
-          kind_checker.module_eval("def self.__kind; #{kind_name}; end")
+          kind_checker = ::Module.new { extend Checkable }
+          kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)
-          kind_of_mod.const_set(checker, kind_checker)
+          kind_of_mod.const_set(method_name, kind_checker)
         end
 
-        unless kind_is_mod.respond_to?(checker)
+        unless kind_is_mod.respond_to?(method_name)
           kind_is_mod.instance_eval(KIND_IS % params)
-          kind_is_mod.const_set(checker, Module.new) if create_kind_is_mod
+          kind_is_mod.const_set(method_name, Module.new) if create_kind_is_mod
         end
       end
   end

data/lib/kind/undefined.rb

@@ -3,7 +3,7 @@
 module Kind
   Undefined = Object.new.tap do |undefined|
     def undefined.inspect
-      @inspect ||= 'Undefined'.freeze
+      @inspect ||= 'Kind::Undefined'.freeze
     end
 
     def undefined.to_s

data/lib/kind/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-12 00:00:00.000000000 Z
+date: 2020-04-17 00:00:00.000000000 Z
 dependencies: []
 description: Basic type system for Ruby (free of dependencies).
 email:
@@ -29,6 +29,7 @@ files:
 - kind.gemspec
 - lib/kind.rb
 - lib/kind/checker.rb
+- lib/kind/empty.rb
 - lib/kind/error.rb
 - lib/kind/is.rb
 - lib/kind/maybe.rb