kind 2.0.0 → 3.0.1

data/lib/kind/error.rb

@@ -7,7 +7,7 @@ module Kind
     private_constant :UNDEFINED_OBJECT
 
     def initialize(arg, object = UNDEFINED_OBJECT)
-      if object == UNDEFINED_OBJECT
+      if UNDEFINED_OBJECT == object
         # Will be used when the exception was raised with a message. e.g:
         # raise Kind::Error, "some message"
         super(arg)

data/lib/kind/maybe.rb

@@ -2,9 +2,22 @@
 
 module Kind
   module Maybe
+    class Typed
+      def initialize(kind)
+        @kind_checker = Kind::Checker::Factory.create(kind)
+      end
+
+      def wrap(value)
+        @kind_checker.as_maybe(value)
+      end
+
+      alias_method :new, :wrap
+      alias_method :[], :wrap
+    end
+
     module Value
       def self.none?(value)
-        value == nil || value == Undefined
+        value.nil? || Undefined == value
       end
 
       def self.some?(value)
@@ -16,7 +29,7 @@ module Kind
       attr_reader :value
 
       def initialize(value)
-        @value = value
+        @value = value.kind_of?(Result) ? value.value : value
       end
 
       def value_or(method_name = Undefined, &block)
@@ -42,9 +55,9 @@ module Kind
       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 default == Undefined && !block
+        raise ArgumentError, INVALID_DEFAULT_ARG if Undefined == default && !block
 
-        Maybe::Value.some?(default) ? default : block.call
+        Undefined != default ? default : block.call
       end
 
       def none?; true; end
@@ -55,12 +68,14 @@ module Kind
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if method_name != Undefined
+      def try!(method_name = Undefined, *args, &block)
+        Kind.of.Symbol(method_name) if Undefined != method_name
 
-        nil
+        NONE_WITH_NIL_VALUE
       end
 
+      alias_method :try, :try!
+
       private_constant :INVALID_DEFAULT_ARG
     end
 
@@ -79,32 +94,90 @@ module Kind
       def map(&fn)
         result = fn.call(@value)
 
-        return NONE_WITH_NIL_VALUE if result == nil
-        return NONE_WITH_UNDEFINED_VALUE if result == Undefined
-
-        Some.new(result)
+        resolve(result)
       end
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, *args, &block)
-        fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
+      def try!(method_name = Undefined, *args, &block)
+        Kind::Of::Symbol(method_name) if Undefined != method_name
 
-        result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
+        __try__(method_name, args, block)
+      end
 
-        return result if Maybe::Value.some?(result)
+      def try(method_name = Undefined, *args, &block)
+        if (Undefined != method_name && value.respond_to?(Kind::Of::Symbol(method_name))) ||
+           (Undefined == method_name && block)
+          __try__(method_name, args, block)
+        else
+          NONE_WITH_NIL_VALUE
+        end
       end
+
+      private
+
+        def __try__(method_name = Undefined, args, block)
+          fn = Undefined == method_name ? block : method_name.to_proc
+
+          result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
+
+          resolve(result)
+        end
+
+        def resolve(result)
+          return result if Maybe::None === result
+          return NONE_WITH_NIL_VALUE if result.nil?
+          return NONE_WITH_UNDEFINED_VALUE if Undefined == result
+
+          Some.new(result)
+        end
     end
 
     def self.new(value)
       result_type = Maybe::Value.none?(value) ? None : Some
-      result_type.new(value.is_a?(Result) ? value.value : value)
+      result_type.new(value)
     end
 
-    def self.[](value);
+    def self.[](value)
       new(value)
     end
+
+    def self.wrap(value)
+      new(value)
+    end
+
+    def self.none
+      NONE_WITH_NIL_VALUE
+    end
+
+    VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
+
+    private_constant :VALUE_CANT_BE_NONE
+
+    def self.some(value)
+      return Maybe::Some.new(value) if Value.some?(value)
+
+      raise ArgumentError, VALUE_CANT_BE_NONE
+    end
   end
 
   Optional = Maybe
+
+  None = Maybe.none
+
+  def self.None
+    Kind::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/types.rb

@@ -10,15 +10,25 @@ module Kind
       def self.%{method_name}(object = Undefined, options = Empty::HASH)
         default = options[:or]
 
-        return Kind::Of::%{kind_name} if object == Undefined && default.nil?
+        return Kind::Of::%{kind_name} if Undefined == object && default.nil?
 
-        Kind::Of.(::%{kind_name_to_check}, (object || default))
+        is_instance = Kind::Of::%{kind_name}.__is_instance__(object)
+
+        return object if is_instance
+
+        Kind::Of.(::%{kind_name_to_check}, object && default ? default : object || default)
+      end
+    RUBY
+
+    KIND_OF_IS = <<-RUBY
+      def self.%{method_name}?(*args)
+        Kind::Of::%{kind_name}.instance?(*args)
       end
     RUBY
 
     KIND_IS = <<-RUBY
       def self.%{method_name}(value = Undefined)
-        return Kind::Is::%{kind_name} if value == Undefined
+        return Kind::Is::%{kind_name} if Undefined == value
 
         Kind::Is.__call__(::%{kind_name_to_check}, value)
       end
@@ -88,11 +98,12 @@ module Kind
           kind_name = params[:kind_name]
           params[:kind_name_to_check] ||= kind_name
 
-          kind_checker = ::Module.new { extend Checkable }
+          kind_checker = ::Module.new { extend Checker::Protocol }
           kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)
           kind_of_mod.const_set(method_name, kind_checker)
+          kind_of_mod.instance_eval(KIND_OF_IS % params)
         end
 
         unless kind_is_mod.respond_to?(method_name)

data/lib/kind/undefined.rb

@@ -19,7 +19,7 @@ module Kind
     end
 
     def undefined.default(value, default)
-      return self if value != self
+      return self if self != value
 
       default.respond_to?(:call) ? default.call : default
     end

data/lib/kind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kind
-  VERSION = '2.0.0'
+  VERSION = '3.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-07 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
@@ -32,6 +32,8 @@ files:
 - lib/kind/active_model/kind_validator.rb
 - lib/kind/active_model/validation.rb
 - lib/kind/checker.rb
+- lib/kind/checker/factory.rb
+- lib/kind/checker/protocol.rb
 - lib/kind/empty.rb
 - lib/kind/error.rb
 - lib/kind/is.rb