kind 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b922b130910037cd09fff2d0743e29aada4825e1d8acb6c11e1a00339fbafe9b
-  data.tar.gz: e7f0322e4690b6a8f72899f5811118731b324d787f37486b433d5b6774e001f8
+  metadata.gz: dfe4558ce7a6bb67a5c7cb76d0ab12465ef644a909cc6f52e6c7890327db3a13
+  data.tar.gz: 511872fbaaf0884287c2d5c8e8e0e871ba832c828892ab9124f38cb458b6a2d6
 SHA512:
-  metadata.gz: 35affc63747d867f6564345d4eb2acb2687cfa33919fc4059a54fd0413fda837cf7207e869b3d28d2fccf4145e1846d13340066124cfdd735082b9b56da19b0f
-  data.tar.gz: 04cfd8e97685d1e423d32bff405719144c9b868320528b3eef304b939e9b76520567a32f458933ecb51f9878c0677bd196670b9547cc9dfea358f67b86dc8855
+  metadata.gz: 5d540ca9ec1ae62b1c560c9a3791742312832c7a4bd663cc319a5d2ac4ea7ed4a47c97de5810114d2a12f930bcf824513b058eaca37c3c736c136e5060eb55e1
+  data.tar.gz: 3b3e80863478ca100746dfe778ea1cccf9a66d19fe4748b0f07e7c1f27e987b11bf673b35b8f797fcb21b693f69ad3692b39d2a4b8433dc302b33cf1dca15bfa

data/README.md

@@ -27,9 +27,9 @@ One of the goals of this project is to do simple type checking like `"some strin
     - [Kind.of](#kindof)
     - [Kind.is](#kindis)
 - [Kind::Undefined](#kindundefined)
-- [Kind::Optional](#kindoptional)
-  - [Kind::Optional[] and Kind::Optional#then](#kindoptional-and-kindoptionalthen)
-  - [Kind::Optional#try](#kindoptionaltry)
+- [Kind::Maybe](#kindmaybe)
+  - [Kind::Maybe[] and Kind::Maybe#then](#kindmaybe-and-kindmaybethen)
+  - [Kind::Maybe#try](#kindmaybetry)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -288,15 +288,15 @@ If you are interested, check out [the tests](https://github.com/serradura/kind/b
 
 [⬆️ Back to Top](#table-of-contents-)
 
-## Kind::Optional
+## Kind::Maybe
 
-The `Kind::Optional` is used when a series of computations (in a chain of map callings) could return `nil` or `Kind::Undefined` at any point.
+The `Kind::Maybe` is used when a series of computations (in a chain of map callings) could return `nil` or `Kind::Undefined` at any point.
 
 ```ruby
 optional =
-  Kind::Optional.new(2)
-                .map { |value| value * 2 }
-                .map { |value| value * 2 }
+  Kind::Maybe.new(2)
+             .map { |value| value * 2 }
+             .map { |value| value * 2 }
 
 puts optional.value # 8
 puts optional.some? # true
@@ -309,9 +309,9 @@ puts optional.value_or { 0 } # 8
 #################
 
 optional =
-  Kind::Optional.new(3)
-                .map { nil }
-                .map { |value| value * 3 }
+  Kind::Maybe.new(3)
+             .map { nil }
+             .map { |value| value * 3 }
 
 puts optional.value # nil
 puts optional.some? # false
@@ -324,9 +324,9 @@ puts optional.value_or { 0 } # 0
 #############################
 
 optional =
-  Kind::Optional.new(4)
-                .map { Kind::Undefined }
-                .map { |value| value * 4 }
+  Kind::Maybe.new(4)
+             .map { Kind::Undefined }
+             .map { |value| value * 4 }
 
 puts optional.value # Kind::Undefined
 puts optional.some? # false
@@ -335,13 +335,13 @@ puts optional.value_or(1) # 1
 puts optional.value_or { 1 } # 1
 ```
 
-### Kind::Optional[] and Kind::Optional#then
+### Kind::Maybe[] and Kind::Maybe#then
 
-You can use `Kind::Option[]` (brackets) instead of the `.new` to transform values in a `Kind::Optional`. Another alias is `.then` to the `.map` method.
+You can use `Kind::Maybe[]` (brackets) instead of the `.new` to transform values in a `Kind::Maybe`. Another alias is `.then` to the `.map` method.
 
 ```ruby
 result =
-  Kind::Optional[5]
+  Kind::Maybe[5]
     .then { |value| value * 5 }
     .then { |value| value + 17 }
     .value_or(0)
@@ -349,30 +349,36 @@ result =
 puts result # 42
 ```
 
-### Kind::Optional#try
+### Kind::Maybe#try
 
 If you don't want to use a map to access the value, you could use the `#try` method to access it. So, if the value wasn't `nil` or `Kind::Undefined`, it will be returned.
 
 ```ruby
-p Kind::Optional['foo'].try(:upcase) # "FOO"
+object = 'foo'
 
-p Kind::Optional['bar'].try { |value| value.upcase } # "BAR"
+p Kind::Maybe[object].try(:upcase) # "FOO"
+
+p Kind::Maybe[object].try { |value| value.upcase } # "FOO"
 
 #############
 # Nil value #
 #############
 
-p Kind::Optional[nil].try(:upcase) # nil
+object = nil
+
+p Kind::Maybe[object].try(:upcase) # nil
 
-p Kind::Optional[nil].try { |value| value.upcase } # nil
+p Kind::Maybe[object].try { |value| value.upcase } # nil
 
 #########################
 # Kind::Undefined value #
 #########################
 
-p Kind::Optional[Kind::Undefined].try(:upcase) # nil
+object = Kind::Undefined
+
+p Kind::Maybe[object].try(:upcase) # nil
 
-p Kind::Optional[Kind::Undefined].try { |value| value.upcase } # nil
+p Kind::Maybe[object].try { |value| value.upcase } # nil
 ```
 
 [⬆️ Back to Top](#table-of-contents-)

data/lib/kind/maybe.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    def self.none?(value)
+      value == nil || value == Undefined
+    end
+
+    def self.some?(value)
+      !none?(value)
+    end
+
+    def self.new(value)
+      result_type = some?(value) ? Some : None
+      result_type.new(value.is_a?(Result) ? value.value : value)
+    end
+
+    def self.[](value);
+      new(value)
+    end
+
+    class Result
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
+
+      def value_or(default = Undefined, &block)
+        return @value if some?
+
+        if default == Undefined && !block
+          raise ArgumentError, INVALID_DEFAULT_ARG
+        else
+          Maybe.some?(default) ? default : block.call
+        end
+      end
+
+      def none?; end
+
+      def some?; !none?; end
+
+      def map(&fn); end
+
+      def try(method_name = Undefined, &block)
+        fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
+
+        if Maybe.some?(value)
+          result = fn.call(value)
+
+          return result if Maybe.some?(result)
+        end
+      end
+
+      private_constant :INVALID_DEFAULT_ARG
+    end
+
+    class None < Result
+      def none?; true; end
+
+      def map(&fn)
+        self
+      end
+
+      alias_method :then, :map
+    end
+
+    NONE_WITH_NIL = None.new(nil)
+    NONE_WITH_UNDEFINED = None.new(Undefined)
+
+    class Some < Result
+      def none?; false; end
+
+      def map(&fn)
+        result = yield(@value)
+
+        return NONE_WITH_NIL if result == nil
+        return NONE_WITH_UNDEFINED if result == Undefined
+        return Some.new(result)
+      end
+
+      alias_method :then, :map
+    end
+
+    private_constant :Result, :NONE_WITH_NIL, :NONE_WITH_UNDEFINED
+  end
+
+  Optional = Maybe
+end

data/lib/kind/version.rb

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

data/lib/kind.rb

@@ -2,7 +2,7 @@
 
 require 'kind/version'
 require 'kind/undefined'
-require 'kind/optional'
+require 'kind/maybe'
 require 'kind/error'
 require 'kind/is'
 require 'kind/checker'
@@ -101,7 +101,7 @@ module Kind
 
       return Kind::Of::Callable if object == Undefined && default.nil?
 
-      callable = object.nil? ? default : object
+      callable = object || default
 
       return callable if callable.respond_to?(:call)
 
@@ -113,7 +113,9 @@ module Kind
 
       def self.__kind; Object; end
 
-      def self.class?(value); Kind::Is::Callable(value); end
+      def self.class?(value)
+        Kind::Is::Callable(value)
+      end
 
       def self.instance?(value);
         value.respond_to?(:call)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura
@@ -31,8 +31,8 @@ files:
 - lib/kind/checker.rb
 - lib/kind/error.rb
 - lib/kind/is.rb
+- lib/kind/maybe.rb
 - lib/kind/of.rb
-- lib/kind/optional.rb
 - lib/kind/types.rb
 - lib/kind/undefined.rb
 - lib/kind/version.rb

data/lib/kind/optional.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  class Optional
-    self.singleton_class.send(:alias_method, :[], :new)
-
-    IsNone = -> value { value == nil || value == Undefined }
-
-    attr_reader :value
-
-    def initialize(arg)
-      @value = arg.is_a?(Kind::Optional) ? arg.value : arg
-    end
-
-    INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
-
-    def value_or(default = Undefined, &block)
-      return @value if some?
-
-      if default == Undefined && !block
-        raise ArgumentError, INVALID_DEFAULT_ARG
-      else
-        IsNone.(default) ? block.call : default
-      end
-    end
-
-    def none?
-      @none ||= IsNone.(@value)
-    end
-
-    def some?
-      !none?
-    end
-
-    def map(&fn)
-      return self if none?
-
-      self.class.new(fn.call(@value))
-    end
-
-    alias_method :then, :map
-
-    def try(method_name = Undefined, &block)
-      fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
-
-      unless IsNone.(value)
-        result = fn.call(value)
-
-        return result unless IsNone.(result)
-      end
-    end
-
-    private_constant :IsNone, :INVALID_DEFAULT_ARG
-  end
-end