kind 5.1.0 → 5.2.0

data/lib/kind/immutable_attributes/reader.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/__lib__/attributes'
+
+module Kind
+  module ImmutableAttributes
+
+    module Reader
+      def self.included(base)
+        base.send(:attr_reader, :attributes)
+      end
+
+      def attribute?(name)
+        self.class.__attributes__.key?(name.to_sym)
+      end
+
+      def attribute(name)
+        @attributes[name.to_sym]
+      end
+
+      def attribute!(name)
+        @attributes.fetch(name.to_sym)
+      end
+
+      def with_attribute(name, value)
+        self.class.new(@_____attrs.merge(name.to_sym => value))
+      end
+
+      def with_attributes(arg)
+        hash = KIND.of!(::Hash, arg)
+
+        self.class.new(@_____attrs.merge(hash))
+      end
+    end
+
+  end
+end

data/lib/kind/maybe.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+
+module Kind
+  module Maybe
+    require 'kind/maybe/monad'
+    require 'kind/maybe/none'
+    require 'kind/maybe/some'
+    require 'kind/maybe/wrapper'
+    require 'kind/maybe/typed'
+    require 'kind/maybe/methods'
+
+    extend self
+
+    def new(value)
+      (::Exception === value || KIND.null?(value) ? None : Some)
+        .new(value)
+    end
+
+    alias_method :[], :new
+
+    module Buildable
+      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_method :optional, :maybe
+
+      private
+
+        def __maybe
+          @__maybe ||= Maybe::Typed[self]
+        end
+    end
+
+    extend Wrapper
+  end
+
+  Optional = Maybe
+
+  None = Maybe::NONE_INSTANCE
+
+  def self.None
+    Maybe::NONE_INSTANCE
+  end
+
+  def self.Some(value)
+    Maybe::Some[value]
+  end
+
+  def self.Maybe(kind)
+    warn '[DEPRECATION] Kind::Maybe() is deprecated; use Kind::Maybe::Typed[] instead. ' \
+        'It will be removed on next major release.'
+
+    Maybe::Typed[kind]
+  end
+
+  def self.Optional(kind)
+    warn '[DEPRECATION] Kind::Optional() is deprecated; use Kind::Optional::Typed[] instead. ' \
+        'It will be removed on next major release.'
+
+    Optional::Typed[kind]
+  end
+end

data/lib/kind/maybe/methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe::Methods
+    def Maybe(&block)
+      Kind::Maybe.from(&block)
+    end
+
+    def None
+      Kind::Maybe::NONE_INSTANCE
+    end
+
+    def Some(value = UNDEFINED, &block)
+      UNDEFINED == value && block ? Maybe(&block) : Kind::Maybe[value]
+    end
+
+    def self.included(base)
+      base.send(:private, :Some, :None)
+    end
+  end
+end

data/lib/kind/maybe/monad.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class Monad
+      require 'kind/maybe/monad/wrapper'
+
+      attr_reader :value
+
+      Value = ->(arg) { arg.kind_of?(Maybe::Monad) ? arg.value : arg } # :nodoc:
+
+      def initialize(value)
+        @value = Value[value]
+      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
+      alias_method :and_then, :map
+      alias_method :and_then!, :map!
+
+      def check(&fn)
+        raise NotImplementedError
+      end
+
+      alias_method :accept, :check
+      alias_method :reject, :check
+
+      def try(_method_name = UNDEFINED, &block)
+        raise NotImplementedError
+      end
+
+      alias_method :try!, :try
+
+      def dig(*keys)
+        raise NotImplementedError
+      end
+
+      def presence
+        raise NotImplementedError
+      end
+
+      def on
+        monad = Wrapper.new(self)
+
+        yield(monad)
+
+        monad.output
+      end
+
+      def on_some(matcher = UNDEFINED)
+        yield(value) if some? && maybe?(matcher)
+
+        self
+      end
+
+      def on_none(matcher = UNDEFINED)
+        yield(value) if none? && maybe?(matcher)
+
+        self
+      end
+
+      def maybe?(matcher)
+        UNDEFINED == matcher || matcher === value
+      end
+    end
+  end
+end

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/{core/maybe → maybe}/none.rb

@@ -2,18 +2,16 @@
 
 module Kind
   module Maybe
-    class None < Result
-      INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
-
+    class None < Monad
       def value_or(default = UNDEFINED, &block)
-        raise ArgumentError, INVALID_DEFAULT_ARG if UNDEFINED == default && !block
+        Error.invalid_default_arg! if UNDEFINED == default && !block
 
         UNDEFINED != default ? default : block.call
       end
 
       def none?; true; end
 
-      def map(&fn)
+      def map(_method_name = UNDEFINED, &fn)
         self
       end
 
@@ -21,6 +19,10 @@ module Kind
       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
@@ -38,20 +40,11 @@ module Kind
         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)
+      def inspect
+        '#<%s value=%s>' % ['Kind::None', value.inspect]
+      end
     end
 
-    private_constant :NONE_WITH_NIL_VALUE, :NONE_WITH_UNDEFINED_VALUE
+    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