kind 5.1.0 → 5.2.0

data/lib/kind/{core/type_checkers → objects/modules}/stdlib/set.rb

@@ -2,13 +2,15 @@
 
 module Kind
   module Set
-    extend self, TypeChecker
+    extend self, ::Kind::Object
 
     def kind; ::Set; end
 
     def value_or_empty(arg)
       KIND.value(self, arg, Empty::SET)
     end
+
+    alias empty_or value_or_empty
   end
 
   def self.Set?(*values)

data/lib/kind/objects/nil.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Nil
+    def self.|(another_kind)
+      UnionType[self] | another_kind
+    end
+
+    def self.name
+      'nil'
+    end
+
+    def self.===(value)
+      value.nil?
+    end
+  end
+end

data/lib/kind/objects/not_nil.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module NotNil
+    def self.[](value, label: nil)
+      return value unless value.nil?
+
+      label_text = label ? "#{label}: " : ''
+
+      raise Error.new("#{label_text}expected to not be nil")
+    end
+  end
+end

data/lib/kind/objects/object.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'kind/maybe'
+
+module Kind
+  module Object
+    include Kind::BasicObject
+    include Maybe::Buildable
+    include UnionType::Buildable
+
+    def name
+      kind.name
+    end
+
+    def ===(value)
+      kind === value
+    end
+
+    def inspect
+      "Kind::Object<#{name}>"
+    end
+  end
+
+  class Object::Instance # :nodoc: all
+    include ::Kind::Object
+
+    ResolveKindName = ->(kind, opt) do
+      name = Try.call!(opt, :[], :name)
+      name || Try.call!(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
+
+  # Kind[]
+  def self.[](kind, opt = Empty::HASH)
+    Object::Instance.new(kind, opt)
+  end
+
+  # Kind::Of()
+  def self.Of(*args)
+    warn '[DEPRECATION] Kind::Of() is deprecated; use Kind[] instead. ' \
+        'It will be removed on next major release.'
+
+    self[*args]
+  end
+end

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| 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/{core/presence.rb → 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.null?(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,31 @@
+# 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(&_)
+      self
+    end
+
+    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,69 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Monad
+    include Result::Abstract
+
+    require 'kind/result/monad/wrapper'
+
+    attr_reader :type, :value
+
+    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, value_must_be_a: nil) # :nodoc:
+      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : 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 ? 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(&_)
+      raise NotImplementedError
+    end
+
+    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,40 @@
+# 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(&fn)
+      map!(&fn)
+    rescue Kind::Monad::Error => e
+      raise e
+    rescue StandardError => e
+      Result::Failure[:exception, e]
+    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
+
+    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::Success', type, value]
+    end
+  end
+end