kind 3.0.1 → 5.1.0

data/lib/kind/checker/factory.rb

@@ -1,35 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-# 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/empty.rb

@@ -1,21 +0,0 @@
-# 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/is.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Is
-    def self.call(expected, object)
-      __call__(Kind::Of.Module(expected), object)
-    end
-
-    def self.__call__(expected_kind, object)
-      kind = Kind::Of.Module(object)
-
-      if kind.is_a?(Class)
-        kind <= expected_kind || false
-      else
-        kind == expected_kind || kind.is_a?(expected_kind)
-      end
-    end
-  end
-end

data/lib/kind/maybe.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-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? || Undefined == value
-      end
-
-      def self.some?(value)
-        !none?(value)
-      end
-    end
-
-    class Result
-      attr_reader :value
-
-      def initialize(value)
-        @value = value.kind_of?(Result) ? value.value : value
-      end
-
-      def value_or(method_name = Undefined, &block)
-        raise NotImplementedError
-      end
-
-      def none?
-        raise NotImplementedError
-      end
-
-      def some?; !none?; end
-
-      def map(&fn)
-        raise NotImplementedError
-      end
-
-      def try(method_name = Undefined, &block)
-        raise NotImplementedError
-      end
-    end
-
-    class None < Result
-      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 Undefined == default && !block
-
-        Undefined != default ? default : block.call
-      end
-
-      def none?; true; end
-
-      def map(&fn)
-        self
-      end
-
-      alias_method :then, :map
-
-      def try!(method_name = Undefined, *args, &block)
-        Kind.of.Symbol(method_name) if Undefined != method_name
-
-        NONE_WITH_NIL_VALUE
-      end
-
-      alias_method :try, :try!
-
-      private_constant :INVALID_DEFAULT_ARG
-    end
-
-    NONE_WITH_NIL_VALUE = None.new(nil)
-    NONE_WITH_UNDEFINED_VALUE = None.new(Undefined)
-
-    private_constant :NONE_WITH_NIL_VALUE, :NONE_WITH_UNDEFINED_VALUE
-
-    class Some < Result
-      def value_or(default = Undefined, &block)
-        @value
-      end
-
-      def none?; false; end
-
-      def map(&fn)
-        result = fn.call(@value)
-
-        resolve(result)
-      end
-
-      alias_method :then, :map
-
-      def try!(method_name = Undefined, *args, &block)
-        Kind::Of::Symbol(method_name) if Undefined != method_name
-
-        __try__(method_name, args, block)
-      end
-
-      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
-
-      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)
-      result_type = Maybe::Value.none?(value) ? None : Some
-      result_type.new(value)
-    end
-
-    def self.[](value)
-      new(value)
-    end
-
-    def self.wrap(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
-
-  def self.Maybe(kind)
-    Maybe::Typed.new(kind)
-  end
-
-  def self.Optional(kind)
-    Maybe::Typed.new(kind)
-  end
-end

data/lib/kind/of.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Of
-    def self.call(kind, object, kind_name = nil)
-      return object if kind === object
-
-      raise Kind::Error.new(kind_name || kind.name, object)
-    end
-  end
-end

data/lib/kind/types.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Types
-    extend self
-
-    COLONS = '::'.freeze
-
-    KIND_OF = <<-RUBY
-      def self.%{method_name}(object = Undefined, options = Empty::HASH)
-        default = options[:or]
-
-        return Kind::Of::%{kind_name} if Undefined == object && default.nil?
-
-        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
-
-    KIND_IS = <<-RUBY
-      def self.%{method_name}(value = Undefined)
-        return Kind::Is::%{kind_name} if Undefined == value
-
-        Kind::Is.__call__(::%{kind_name_to_check}, value)
-      end
-    RUBY
-
-    private_constant :KIND_OF, :KIND_IS, :COLONS
-
-    def add(kind, name: nil)
-      kind_name = Kind.of.Module(kind).name
-      checker = name ? Kind::Of.(String, name) : kind_name
-
-      if checker.include?(COLONS)
-        add_kind_with_namespace(checker, method_name: name)
-      else
-        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:, kind_name_to_check: nil)
-        root_kind_name = method_name ? method_name : kind_name
-
-        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:)
-        raise NotImplementedError if method_name
-
-        const_names = checker.split(COLONS)
-        const_names.each_with_index do |const_name, index|
-          if index == 0
-            add_root(const_name, const_name, method_name: nil, create_kind_is_mod: true)
-          else
-            add_node(const_names, index)
-          end
-        end
-      end
-
-      def add_node(const_names, index)
-        namespace = const_names[0..(index-1)]
-        namespace_name = namespace.join(COLONS)
-
-        kind_of_mod = Kind::Of.const_get(namespace_name)
-        kind_is_mod = Kind::Is.const_get(namespace_name)
-
-        checker = const_names[index]
-        kind_name = const_names[0..index].join(COLONS)
-
-        params = { method_name: checker, kind_name: kind_name }
-
-        add_kind(params, kind_of_mod, kind_is_mod, true)
-      end
-
-      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
-
-          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)
-          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)
-          kind_is_mod.instance_eval(KIND_IS % params)
-          kind_is_mod.const_set(method_name, Module.new) if create_kind_is_mod
-        end
-      end
-  end
-end