kind 2.0.0 → 3.0.1

data/lib/kind.rb

@@ -4,12 +4,12 @@ require 'kind/version'
 
 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,35 +18,23 @@ 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
-
   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
 
-  private_class_method def self.__checkers__
-    @__checkers__ ||= {}
+  def self.of?(kind, *args)
+    Kind.of(kind).instance?(*args)
   end
 
   # --------------------- #
@@ -59,7 +47,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)
@@ -75,13 +63,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
 
@@ -90,19 +78,23 @@ 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)
-      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
@@ -127,7 +119,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
@@ -136,12 +128,16 @@ 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)
       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
 
@@ -151,7 +147,7 @@ module Kind
     end
 
     const_set(:Boolean, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; [TrueClass, FalseClass].freeze; end
 
@@ -163,14 +159,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
@@ -187,12 +183,16 @@ module Kind
       end
     end)
 
+    def self.Boolean?(*args)
+      Kind::Of::Boolean.instance?(*args)
+    end
+
     # -- Lambda
 
     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
 
@@ -202,7 +202,7 @@ module Kind
     end
 
     const_set(:Lambda, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; ::Proc; end
 
@@ -212,14 +212,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
@@ -231,12 +231,16 @@ module Kind
       end
     end)
 
+    def self.Lambda?(*args)
+      Kind::Of::Lambda.instance?(*args)
+    end
+
     # -- Callable
 
     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
 
@@ -246,7 +250,7 @@ module Kind
     end
 
     const_set(:Callable, ::Module.new do
-      extend Checkable
+      extend Checker::Protocol
 
       def self.__kind; Object; end
 
@@ -260,14 +264,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
@@ -279,6 +283,10 @@ module Kind
       end
     end)
 
+    def self.Callable?(*args)
+      Kind::Of::Callable.instance?(*args)
+    end
+
     # ---------------------- #
     # Built-in type checkers #
     # ---------------------- #

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,70 +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 instance?(value = Kind::Undefined)
-      return __is_instance__(value) if value != Kind::Undefined
-
-      to_proc
-    end
-
-    def __is_instance__(value)
-      value.is_a?(__kind)
-    end
-
-    def to_proc
-      @to_proc ||=
-        -> checker { -> value { checker.__is_instance__(value) } }.call(self)
-    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::Undefined)
-      return __as_maybe__(value) if value != Kind::Undefined
-
-      as_maybe_to_proc
-    end
-
-    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
-
   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