kind 5.1.0 → 5.5.0

data/lib/kind/core.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'kind/core/utils/kind'
-require 'kind/core/utils/undefined'
-
-require 'kind/core/error'
-require 'kind/core/empty'
-require 'kind/core/dig'
-require 'kind/core/try'
-require 'kind/core/presence'
-require 'kind/core/undefined'
-require 'kind/core/maybe'
-
-require 'kind/core/type_checker'
-require 'kind/core/type_checkers'

data/lib/kind/core/error.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  class Error < TypeError
-    def initialize(arg, object = UNDEFINED)
-      if UNDEFINED == object
-        # Will be used when the exception was raised with a message. e.g:
-        # raise Kind::Error, "some message"
-        super(arg)
-      else
-        super("#{object.inspect} expected to be a kind of #{arg}")
-      end
-    end
-  end
-end

data/lib/kind/core/maybe.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Maybe
-    require 'kind/core/maybe/result'
-    require 'kind/core/maybe/none'
-    require 'kind/core/maybe/some'
-    require 'kind/core/maybe/wrappable'
-    require 'kind/core/maybe/typed'
-
-    extend self
-
-    def new(value)
-      (KIND.null?(value) ? None : Some)
-        .new(value)
-    end
-
-    alias_method :[], :new
-
-    extend Wrappable
-  end
-
-  Optional = Maybe
-
-  None = Maybe.none
-
-  def self.None
-    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/core/maybe/none.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Maybe
-    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 :map!, :map
-      alias_method :then, :map
-      alias_method :then!, :map
-      alias_method :check, :map
-
-      def try!(method_name = UNDEFINED, *args, &block)
-        KIND.of!(::Symbol, method_name)if UNDEFINED != method_name
-
-        self
-      end
-
-      alias_method :try, :try!
-
-      def dig(*keys)
-        self
-      end
-
-      def presence
-        self
-      end
-
-      private_constant :INVALID_DEFAULT_ARG
-    end
-
-    NONE_WITH_NIL_VALUE = None.new(nil)
-    NONE_WITH_UNDEFINED_VALUE = None.new(Undefined)
-
-    def self.none
-      NONE_WITH_NIL_VALUE
-    end
-
-    def self.__none__(value) # :nodoc:
-      None.new(value)
-    end
-
-    private_constant :NONE_WITH_NIL_VALUE, :NONE_WITH_UNDEFINED_VALUE
-  end
-end

data/lib/kind/core/maybe/result.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Maybe
-    class Result
-      attr_reader :value
-
-      Value = ->(arg) { arg.kind_of?(Maybe::Result) ? arg.value : arg } # :nodoc:
-
-      def initialize(arg)
-        @value = Value.(arg)
-      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
-
-      alias_method :map!, :map
-      alias_method :then, :map
-      alias_method :then!, :map
-
-      def check(&fn)
-        raise NotImplementedError
-      end
-
-      def try(method_name = UNDEFINED, &block)
-        raise NotImplementedError
-      end
-
-      alias_method :try!, :try
-
-      def dig(*keys)
-        raise NotImplementedError
-      end
-
-      def presence
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/kind/core/maybe/some.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Maybe
-    class Some < Result
-      def value_or(default = UNDEFINED, &block)
-        @value
-      end
-
-      def none?; false; end
-
-      def map(&fn)
-        map!(&fn)
-      rescue StandardError => exception
-        None.new(exception)
-      end
-
-      alias_method :then, :map
-
-      def check(&fn)
-        result = fn.call(@value)
-
-        !result || KIND.null?(result) ? NONE_WITH_NIL_VALUE : self
-      end
-
-      def map!(&fn)
-        result = fn.call(@value)
-
-        resolve(result)
-      end
-
-      alias_method :then!, :map!
-
-      def try!(method_name = UNDEFINED, *args, &block)
-        return __try_block__(block, args) if block
-
-        return __try_method__(method_name, args) if UNDEFINED != method_name
-
-        raise ArgumentError, 'method name or a block must be present'
-      end
-
-      def try(method_name = UNDEFINED, *args, &block)
-        return __try_block__(block, args) if block
-
-        return __try_method__(method_name, args) if value.respond_to?(method_name)
-
-        NONE_WITH_NIL_VALUE
-      end
-
-      def dig(*keys)
-        resolve(Dig.(value, keys))
-      end
-
-      def presence
-        resolve(Presence.(value))
-      end
-
-      private
-
-        def __try_method__(method_name, args)
-          __try_block__(KIND.of!(::Symbol, method_name).to_proc, args)
-        end
-
-        def __try_block__(block, args)
-          result = args.empty? ? block.call(value) : block.call(*args.unshift(value))
-
-          resolve(result)
-        end
-
-        def resolve(result)
-          return result if Maybe::None === result
-          return None.new(result) if Exception === result
-          return NONE_WITH_NIL_VALUE if result.nil?
-          return NONE_WITH_UNDEFINED_VALUE if Undefined == result
-
-          Some.new(result)
-        end
-    end
-
-    VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
-
-    def self.some(value)
-      return Maybe::Some.new(value) if !KIND.null?(value)
-
-      raise ArgumentError, VALUE_CANT_BE_NONE
-    end
-
-    private_constant :VALUE_CANT_BE_NONE
-  end
-end

data/lib/kind/core/maybe/typed.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Maybe
-    class Typed
-      include Wrappable
-
-      def initialize(kind)
-        @kind = kind
-      end
-
-      def new(arg)
-        value = Result::Value.(arg)
-
-        @kind === value ? Maybe.some(value) : Maybe.none
-      end
-
-      alias_method :[], :new
-
-      private
-
-        def __call_before_expose_the_arg_in_a_block(arg)
-          value = Result::Value.(arg)
-
-          @kind === value ? value : Maybe.none
-        end
-    end
-  end
-end

data/lib/kind/core/try.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Try
-    extend self
-
-    def call(*args)
-      object = args.shift
-
-      call!(object, args.shift, args)
-    end
-
-    def self.[](*args)
-      method_name = args.shift
-
-      ->(object) { call!(object, method_name, args) }
-    end
-
-    def call!(object, method_name, args) # :nodoc
-      return if KIND.null?(object)
-
-      resolve(object, method_name, args)
-    end
-
-    private
-
-      def resolve(object, method_name, args = Empty::ARRAY)
-        return unless object.respond_to?(method_name)
-        return object.public_send(method_name) if args.empty?
-
-        object.public_send(method_name, *args)
-      end
-  end
-end

data/lib/kind/core/type_checker.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module TypeChecker
-    def name
-      kind.name
-    end
-
-    def ===(value)
-      kind === value
-    end
-
-    def [](value)
-      return value if self === value
-
-      KIND.error!(name, value)
-    end
-
-    def or_nil(value)
-      return value if self === value
-    end
-
-    def or_undefined(value)
-      or_nil(value) || Undefined
-    end
-
-    def or(fallback, value = UNDEFINED)
-      return __or_func.(fallback) if UNDEFINED === value
-
-      self === value ? value : fallback
-    end
-
-    def value?(value = UNDEFINED)
-      return self === value if UNDEFINED != value
-
-      @__is_value ||= ->(tc) { ->(arg) { tc === arg } }.(self)
-    end
-
-    def value(arg, default:)
-      KIND.value(self, arg, self[default])
-    end
-
-    def or_null(value) # :nodoc:
-      KIND.null?(value) ? value : self[value]
-    end
-
-    def maybe(value = UNDEFINED, &block)
-      return __maybe[value] if UNDEFINED != value && !block
-      return __maybe.wrap(&block) if UNDEFINED == value && block
-      return __maybe.wrap(value, &block) if UNDEFINED != value && block
-
-      __maybe
-    end
-
-    alias optional maybe
-
-    private
-
-      def __maybe
-        @__maybe ||= Maybe::Typed.new(self)
-      end
-
-      def __or_func
-        @__or_func ||= ->(tc, fb, value) { tc === value ? value : tc.or_null(fb) }.curry[self]
-      end
-  end
-
-  class TypeChecker::Object # :nodoc: all
-    include TypeChecker
-
-    ResolveKindName = ->(kind, opt) do
-      name = Try.(opt, :[], :name)
-      name || Try.(kind, :name)
-    end
-
-    attr_reader :kind, :name
-
-    def initialize(kind, opt)
-      name = ResolveKindName.(kind, opt)
-
-      @name = KIND.of!(::String, name)
-      @kind = KIND.respond_to!(:===, kind)
-    end
-
-    private_constant :ResolveKindName
-  end
-end

data/lib/kind/core/type_checkers.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'kind/core/type_checkers/ruby/array'
-require 'kind/core/type_checkers/ruby/class'
-require 'kind/core/type_checkers/ruby/comparable'
-require 'kind/core/type_checkers/ruby/enumerable'
-require 'kind/core/type_checkers/ruby/enumerator'
-require 'kind/core/type_checkers/ruby/file'
-require 'kind/core/type_checkers/ruby/float'
-require 'kind/core/type_checkers/ruby/hash'
-require 'kind/core/type_checkers/ruby/integer'
-require 'kind/core/type_checkers/ruby/io'
-require 'kind/core/type_checkers/ruby/module'
-require 'kind/core/type_checkers/ruby/method'
-require 'kind/core/type_checkers/ruby/numeric'
-require 'kind/core/type_checkers/ruby/proc'
-require 'kind/core/type_checkers/ruby/queue'
-require 'kind/core/type_checkers/ruby/range'
-require 'kind/core/type_checkers/ruby/regexp'
-require 'kind/core/type_checkers/ruby/string'
-require 'kind/core/type_checkers/ruby/struct'
-require 'kind/core/type_checkers/ruby/symbol'
-require 'kind/core/type_checkers/ruby/time'
-
-require 'kind/core/type_checkers/stdlib/open_struct'
-require 'kind/core/type_checkers/stdlib/set'
-
-require 'kind/core/type_checkers/custom/boolean'
-require 'kind/core/type_checkers/custom/callable'
-require 'kind/core/type_checkers/custom/lambda'