kind 3.0.1 → 5.1.0

data/lib/kind/core/maybe.rb

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

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

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

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

@@ -0,0 +1,29 @@
+# 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/maybe/wrappable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    module Wrappable
+      def wrap(arg = UNDEFINED)
+        if block_given?
+          begin
+            return new(yield) if UNDEFINED == arg
+
+            input = __call_before_expose_the_arg_in_a_block(arg)
+
+            input.kind_of?(Maybe::None) ? input : new(yield(input))
+          rescue StandardError => exception
+            Maybe.__none__(exception)
+          end
+        else
+          return new(arg) if UNDEFINED != arg
+
+          raise ArgumentError, 'wrong number of arguments (given 0, expected 1)'
+        end
+      end
+
+      private
+
+        def __call_before_expose_the_arg_in_a_block(input)
+          input
+        end
+    end
+
+    private_constant :Wrappable
+  end
+end

data/lib/kind/core/presence.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kind
+  module Presence
+    extend self
+
+    def call(object)
+      return object.blank? ? nil : object if object.respond_to?(:blank?)
+
+      return object if TrueClass === object
+
+      return blank_str?(object) ? nil : object if String === object
+
+      return object.empty? ? nil : object if object.respond_to?(:empty?)
+
+      return object if object
+    end
+
+    def to_proc
+      -> object { call(object) }
+    end
+
+    private
+
+      BLANK_RE = /\A[[:space:]]*\z/
+
+      def blank_str?(object)
+        object.empty? || BLANK_RE === object
+      end
+
+      private_constant :BLANK_RE
+  end
+end

data/lib/kind/core/try.rb

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

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