kind 4.1.0 → 5.4.0

data/lib/kind/objects/respond_to.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kind
+  class RespondTo
+    include Kind::BasicObject
+
+    def self.[](*args)
+      args.each { |arg| STRICT.kind_of(::Symbol, arg) }
+
+      new(args)
+    end
+
+    private_class_method :new
+
+    attr_reader :inspect
+
+    def initialize(method_names)
+      @method_names = method_names
+      @inspect = "Kind::RespondTo#{@method_names}"
+    end
+
+    def ===(value)
+      KIND.interface?(@method_names, value)
+    end
+
+    alias_method :call, :===
+
+    alias_method :name, :inspect
+  end
+end

data/lib/kind/objects/union_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kind
+  class UnionType
+    include Kind::BasicObject
+
+    Interface = Kind::RespondTo[:name, :===]
+
+    singleton_class.send(:alias_method, :[], :new)
+
+    attr_reader :inspect
+
+    def initialize(kind)
+      @kinds = Array(kind)
+      @inspect = "(#{@kinds.map(&:name).join(' | ')})"
+    end
+
+    def |(kind)
+      self.class.new(@kinds + [Interface[kind]])
+    end
+
+    def ===(value)
+      @kinds.any? { |kind| kind === value }
+    end
+
+    alias_method :name, :inspect
+
+    module Buildable
+      def |(another_kind)
+        __union_type | another_kind
+      end
+
+      private
+
+        def __union_type
+          @__union_type ||= UnionType[self]
+        end
+    end
+
+    private_constant :Interface
+  end
+
+  RespondTo.send(:include, UnionType::Buildable)
+end

data/lib/kind/presence.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
+require 'kind/basic'
+
 module Kind
   module Presence
     extend self
 
     def call(object)
-      return object.blank? ? nil : object if object.respond_to?(:blank?)
+      return if KIND.nil_or_undefined?(object)
 
-      return object if TrueClass === object
+      return object.blank? ? nil : object if object.respond_to?(:blank?)
 
       return blank_str?(object) ? nil : object if String === object
 

data/lib/kind/result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+
+module Kind
+  module Result
+    require 'kind/result/abstract'
+    require 'kind/result/monad'
+    require 'kind/result/failure'
+    require 'kind/result/success'
+    require 'kind/result/methods'
+
+    extend self
+
+    def new(value)
+      Success[value]
+    end
+
+    alias_method :[], :new
+
+    def self.from
+      result = yield
+
+      Result::Monad === result ? result : Result::Success[result]
+    rescue StandardError => e
+      Result::Failure[:exception, e]
+    end
+  end
+
+  extend Result::Methods
+end

data/lib/kind/result/abstract.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kind
+  module Result::Abstract
+    def failure?
+      false
+    end
+
+    def failed?
+      failure?
+    end
+
+    def success?
+      false
+    end
+
+    def succeeded?
+      success?
+    end
+
+    def on(&block)
+      raise NotImplementedError
+    end
+
+    def on_success(types = Undefined, matcher = Undefined)
+      raise NotImplementedError
+    end
+
+    def on_failure(types = Undefined, matcher = Undefined)
+      raise NotImplementedError
+    end
+
+    def result?(types, matcher)
+      undef_t = Undefined == (t = types)
+      undef_m = Undefined == (m = matcher)
+
+      return true if undef_t && undef_m
+
+      if !undef_t && undef_m && !(Array === types || Symbol === types)
+        m, t = types, matcher
+
+        undef_m, undef_t = false, true
+      end
+
+      is_type = undef_t || (::Array === t ? t.empty? || t.include?(type) : t == type)
+      is_type && (undef_m || m === value)
+    end
+
+    def to_ary
+      [type, value]
+    end
+  end
+end

data/lib/kind/result/failure.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Failure < Result::Monad
+    DEFAULT_TYPE = :error
+
+    def failure?
+      true
+    end
+
+    def value_or(default = UNDEFINED, &block)
+      Error.invalid_default_arg! if UNDEFINED == default && !block
+
+      UNDEFINED != default ? default : block.call
+    end
+
+    def map(_ = UNDEFINED, &_fn)
+      self
+    end
+
+    alias_method :|, :map
+    alias_method :>>, :map
+    alias_method :map!, :map
+    alias_method :then, :map
+    alias_method :then!, :map
+    alias_method :and_then, :map
+    alias_method :and_then!, :map
+
+    def inspect
+      '#<%s type=%p value=%p>' % ['Kind::Failure', type, value]
+    end
+  end
+end

data/lib/kind/result/methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Result::Methods
+    def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+      Result::Failure[arg1, arg2]
+    end
+
+    def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+      Result::Success[arg1, arg2]
+    end
+
+    def self.included(base)
+      base.send(:private, :Success, :Failure)
+    end
+  end
+end

data/lib/kind/result/monad.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Monad
+    include Result::Abstract
+
+    require 'kind/empty'
+    require 'kind/result/monad/wrapper'
+
+    attr_reader :type, :value
+
+    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, opt = Empty::HASH) # :nodoc:
+      value_must_be_a = opt[:value_must_be_a]
+
+      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : STRICT.kind_of(::Symbol, arg1)
+
+      Error.wrong_number_of_args!(given: 0, expected: '1 or 2') if UNDEFINED == arg1
+
+      value = UNDEFINED == arg2 ? arg1 : arg2
+
+      new(type, (value_must_be_a ? STRICT.kind_of(value_must_be_a, value) : value))
+    end
+
+    private_class_method :new
+
+    def initialize(type, value)
+      @type = type
+      @value = value
+    end
+
+    def value_or(_method_name = UNDEFINED, &block)
+      raise NotImplementedError
+    end
+
+    def map(_ = UNDEFINED, &_fn)
+      raise NotImplementedError
+    end
+
+    alias_method :|, :map
+    alias_method :>>, :map
+    alias_method :map!, :map
+    alias_method :then, :map
+    alias_method :then!, :map
+    alias_method :and_then, :map
+    alias_method :and_then!, :map
+
+    def on
+      monad = Wrapper.new(self)
+
+      yield(monad)
+
+      monad.output
+    end
+
+    def on_success(types = Undefined, matcher = Undefined)
+      yield(value) if success? && result?(types, matcher)
+
+      self
+    end
+
+    def on_failure(types = Undefined, matcher = Undefined)
+      yield(value) if failure? && result?(types, matcher)
+
+      self
+    end
+
+    def ===(m)
+      return false unless Result::Abstract === m
+      return false unless (self.success? && m.success?) || (self.failure? && m.failure?)
+
+      self.type == m.type && self.value === m.value
+    end
+  end
+end

data/lib/kind/result/monad/wrapper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kind
+  require 'kind/monad'
+
+  class Result::Monad::Wrapper < Kind::Monad::Wrapper
+    def failure(types = Undefined, matcher = Undefined)
+      return if @monad.success? || output?
+
+      @output = yield(@monad.value) if @monad.result?(types, matcher)
+    end
+
+    def success(types = Undefined, matcher = Undefined)
+      return if @monad.failure? || output?
+
+      @output = yield(@monad.value) if @monad.result?(types, matcher)
+    end
+  end
+end

data/lib/kind/result/success.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Success < Result::Monad
+    DEFAULT_TYPE = :ok
+
+    def success?
+      true
+    end
+
+    def value_or(_default = UNDEFINED, &block)
+      @value
+    end
+
+    def map(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
+    rescue Kind::Monad::Error => e
+      raise e
+    rescue StandardError => e
+      Result::Failure[:exception, e]
+    end
+
+    alias_method :then, :map
+    alias_method :and_then, :map
+
+    def map!(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
+    end
+
+    alias_method :|, :map!
+    alias_method :>>, :map!
+    alias_method :then!, :map!
+    alias_method :and_then!, :map!
+
+    def inspect
+      '#<%s type=%p value=%p>' % ['Kind::Success', type, value]
+    end
+
+    private
+
+      def _resolve_map(callable, fn)
+        callable.respond_to?(:call) ? _map(callable) : _map(fn)
+      end
+
+      def _map(fn)
+        monad = fn.call(@value)
+
+        return monad if Result::Monad === monad
+
+        raise Kind::Monad::Error.new('Kind::Success | Kind::Failure', monad)
+      end
+  end
+end

data/lib/kind/strict/disabled.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kind
+  module STRICT
+    [
+      :object_is_a, :class!, :kind_of,
+      :module_or_class, :module!, :not_nil
+    ].each { |method_name| remove_method(method_name) }
+
+    def object_is_a(_kind, value, _label = nil) # :nodoc:
+      value
+    end
+
+    def class!(value) # :nodoc:
+      value
+    end
+
+    def kind_of(_kind, value, _kind_name = nil) # :nodoc:
+      value
+    end
+
+    def module_or_class(value) # :nodoc:
+      value
+    end
+
+    def module!(value) # :nodoc:
+      value
+    end
+
+    def not_nil(value, label) # :nodoc:
+      value
+    end
+  end
+end

data/lib/kind/try.rb

@@ -1,30 +1,42 @@
 # frozen_string_literal: true
 
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/presence'
+
 module Kind
   module Try
     extend self
 
-    def call(*args)
-      object = args.shift
+    def call!(object, method_name, args = Empty::ARRAY) # :nodoc
+      return if KIND.nil_or_undefined?(object)
 
-      call!(object, args.shift, args)
+      resolve(object, method_name, args)
     end
 
-    def self.[](*args)
-      method_name = args.shift
+    def call(object, *input)
+      args = input.size == 1 && input[0].kind_of?(::Array) ? input[0] : input
 
-      ->(object) { call!(object, method_name, args) }
+      result = call!(object, args.shift, args)
+
+      return result unless block_given?
+
+      yield(result) unless KIND.nil_or_undefined?(result)
     end
 
-    def call!(object, method_name, args) # :nodoc
-      return if KIND.null?(object)
+    def presence(*args, &block)
+      Presence.(call(*args, &block))
+    end
 
-      resolve(object, method_name, args)
+    def self.[](*args)
+      method_name = args.shift
+
+      ->(object) { call!(object, method_name, args) }
     end
 
     private
 
-      def resolve(object, method_name, args = Empty::ARRAY)
+      def resolve(object, method_name, args)
         return unless object.respond_to?(method_name)
         return object.public_send(method_name) if args.empty?