kind 3.1.0 → 5.2.0

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kind
+  require 'kind/monad'
+
+  class Maybe::Monad::Wrapper < Kind::Monad::Wrapper
+    def none(matcher = UNDEFINED)
+      return if @monad.some? || output?
+
+      @output = yield(@monad.value) if @monad.maybe?(matcher)
+    end
+
+    def some(matcher = UNDEFINED)
+      return if @monad.none? || output?
+
+      @output = yield(@monad.value) if @monad.maybe?(matcher)
+    end
+  end
+end

data/lib/kind/maybe/none.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class None < Monad
+      def value_or(default = UNDEFINED, &block)
+        Error.invalid_default_arg! if UNDEFINED == default && !block
+
+        UNDEFINED != default ? default : block.call
+      end
+
+      def none?; true; end
+
+      def map(_method_name = UNDEFINED, &fn)
+        self
+      end
+
+      alias_method :map!, :map
+      alias_method :then, :map
+      alias_method :then!, :map
+      alias_method :check, :map
+      alias_method :accept, :map
+      alias_method :reject, :map
+      alias_method :and_then, :map
+      alias_method :and_then!, :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
+
+      def inspect
+        '#<%s value=%s>' % ['Kind::None', value.inspect]
+      end
+    end
+
+    NONE_INSTANCE = None.new(nil)
+  end
+end

data/lib/kind/maybe/some.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'kind/dig'
+require 'kind/presence'
+
+module Kind
+  module Maybe
+    class Some < Monad
+      KindSymbol = ->(value) { KIND.of!(::Symbol, value) }
+
+      VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
+
+      def self.[](value)
+        return new(value) if !KIND.null?(value)
+
+        raise ArgumentError, VALUE_CANT_BE_NONE
+      end
+
+      def value_or(_default = UNDEFINED, &block)
+        @value
+      end
+
+      def none?; false; end
+
+      def map(method_name = UNDEFINED, &fn)
+        map!(method_name, &fn)
+      rescue StandardError => exception
+        None.new(exception)
+      end
+
+      alias_method :then, :map
+      alias_method :and_then, :map
+
+      def map!(method_name = UNDEFINED, &fn)
+        result = if UNDEFINED != method_name
+          return NONE_INSTANCE unless @value.respond_to?(KindSymbol[method_name])
+
+          @value.public_send(method_name)
+        else
+          fn.call(@value)
+        end
+
+        resolve(result)
+      end
+
+      alias_method :then!, :map!
+      alias_method :and_then!, :map!
+
+      def check(method_name = UNDEFINED, &fn)
+        result = if UNDEFINED != method_name
+          if method_name.kind_of?(::Symbol)
+            @value.respond_to?(method_name) ? @value.public_send(method_name) : NONE_INSTANCE
+          else
+            method_name === @value
+          end
+        else
+          fn.call(@value)
+        end
+
+        !result || KIND.null?(result) ? NONE_INSTANCE : self
+      end
+
+      alias_method :accept, :check
+
+      def reject(method_name = UNDEFINED, &fn)
+        result = if UNDEFINED != method_name
+          if method_name.kind_of?(::Symbol)
+            @value.respond_to?(method_name) ? @value.public_send(method_name) : NONE_INSTANCE
+          else
+            method_name === @value
+          end
+        else
+          fn.call(@value)
+        end
+
+        result || KIND.null?(result) ? NONE_INSTANCE : self
+      end
+
+      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_INSTANCE
+      rescue TypeError
+        NONE_INSTANCE
+      end
+
+      def dig(*keys)
+        resolve(Dig.call!(value, keys))
+      end
+
+      def presence
+        resolve(Presence.(value))
+      end
+
+      def inspect
+        '#<%s value=%s>' % ['Kind::Some', value.inspect]
+      end
+
+      private
+
+        def __try_method__(method_name, args)
+          __try_block__(KindSymbol[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_INSTANCE if KIND.null?(result)
+          return None.new(result) if ::Exception === result
+
+          Some.new(result)
+        end
+
+        private_constant :KindSymbol, :VALUE_CANT_BE_NONE
+    end
+  end
+end

data/lib/kind/maybe/typed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class Typed
+      include Wrapper
+
+      singleton_class.send(:alias_method, :[], :new)
+
+      def initialize(kind)
+        @kind = kind
+      end
+
+      def new(arg)
+        value = Monad::Value[arg]
+
+        @kind === value ? Maybe::Some[value] : Maybe::NONE_INSTANCE
+      end
+
+      alias_method :[], :new
+
+      def inspect
+        "Kind::Maybe<#{@kind}>"
+      end
+
+      private
+
+        def __call_before_expose_the_arg_in_a_block(arg)
+          value = Monad::Value[arg]
+
+          @kind === value ? value : Maybe::NONE_INSTANCE
+        end
+    end
+  end
+end

data/lib/kind/maybe/wrapper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    module Wrapper
+      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.new(exception)
+          end
+        else
+          return new(arg) if UNDEFINED != arg
+
+          Error.wrong_number_of_args!(given: 0, expected: 1)
+        end
+      end
+
+      def from(&block)
+        wrap(&block)
+      end
+
+      private
+
+        def __call_before_expose_the_arg_in_a_block(input)
+          input
+        end
+    end
+
+    private_constant :Wrapper
+  end
+end

data/lib/kind/monad.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kind
+  module Monad
+    Error = ::Class.new(Kind::Error)
+
+    class Wrapper
+      def initialize(monad)
+        @monad = monad
+        @output = UNDEFINED
+      end
+
+      def output?
+        UNDEFINED != @output
+      end
+
+      def output
+        @output if output?
+      end
+    end
+  end
+end

data/lib/kind/monads.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'kind/maybe'
+require 'kind/either'
+require 'kind/result'

data/lib/kind/objects.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'kind/try'
+require 'kind/maybe'
+
+require 'kind/objects/basic_object'
+require 'kind/objects/respond_to'
+require 'kind/objects/union_type'
+require 'kind/objects/nil'
+require 'kind/objects/not_nil'
+require 'kind/objects/object'
+require 'kind/objects/modules'
+
+module Kind
+  UnionType.send(:include, Maybe::Buildable)
+  RespondTo.send(:include, Maybe::Buildable)
+end

data/lib/kind/objects/basic_object.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kind
+  module BasicObject
+    def [](value, label: nil)
+      return value if self === value
+
+      KIND.error!(name, value, label)
+    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
+
+    private
+
+      def __or_func
+        @__or_func ||= ->(tc, fb, value) { tc === value ? value : tc.or_null(fb) }.curry[self]
+      end
+  end
+end

data/lib/kind/objects/modules.rb

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

data/lib/kind/objects/modules/core/array.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kind
+  module Array
+    extend self, ::Kind::Object
+
+    def kind; ::Array; end
+
+    def value_or_empty(arg)
+      KIND.value(self, arg, Empty::ARRAY)
+    end
+
+    alias empty_or value_or_empty
+  end
+
+  def self.Array?(*values)
+    KIND.of?(::Array, values)
+  end
+end

data/lib/kind/objects/modules/core/class.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kind
+  module Class
+    extend self, ::Kind::Object
+
+    def kind; ::Class; end
+  end
+
+  def self.Class?(*values)
+    KIND.of?(::Class, values)
+  end
+end