kind 2.3.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a234e4c63dea23906a65da0718515bff19ac7934a3e919535596042cfd605bba
-  data.tar.gz: 5bcb0f1f669a0e87de070c5095cf8f769ddf97dde4b2169060fb21769ffbd623
+  metadata.gz: a0a947ffbd4a82b5ca7a74006ae8383c725393e1e8640364dc9e73874aac0eb0
+  data.tar.gz: d49f7382d4786e079c42ee7f45609ca8ca292ccb04e4d8ac299cdfa4cbf2e1c8
 SHA512:
-  metadata.gz: 232d87a65618b51c3ec8756ad9d08bce53a49d50368d4629c8e694050502dddf12cdecd878193e40e09c8fcc13139b1a35383eedaa36a1660f7cf71f7e4d9810
-  data.tar.gz: 4cef62a76d8981fa7409e0d598448b35b4bb01794084ad2ab264741cbf0a78e6b9142352369892e124f130750847078f90297e5d1eda955881ebea0f13e96ec7
+  metadata.gz: 77195516f80bae446150221c3c95a621ecacb70335f4594242b3d7f60e9de7ed5be32624c02183faf1ab5cc4717b0c229c82c52ec70aad6122d1fe51a71dfc92
+  data.tar.gz: 1f7ab4c70b8548dda0707d31ba9d500946c5314d8d9462ecdcd5ca0b23f1a197691d0eb6586e4a1628426794f1495d0303d2b1b7c4b32a1bcc73fdc88ea1123b

data/README.md

@@ -48,6 +48,7 @@ One of the goals of this project is to do simple type checking like `"some strin
   - [Kind.of.\<Type\>.as_optional](#kindoftypeas_optional)
   - [Kind::Maybe(<Type>)](#kindmaybetype)
   - [Kind::Maybe#try](#kindmaybetry)
+  - [Kind::Maybe#try!](#kindmaybetry-1)
 - [Kind::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
@@ -883,10 +884,11 @@ In these scenarios, you could check the given input type as optional and avoid u
 
 ```ruby
 def person_name(params)
-  Kind::Of::Hash.as_optional(params)
-                .map { |data| data if data.values_at(:first_name, :last_name).compact.size == 2 }
-                .map { |data| "#{data[:first_name]} #{data[:last_name]}" }
-                .value_or { 'John Doe' }
+  Kind::Of::Hash
+    .as_optional(params)
+    .map { |data| data if data.values_at(:first_name, :last_name).compact.size == 2 }
+    .map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+    .value_or { 'John Doe' }
 end
 
 person_name('')   # "John Doe"
@@ -907,6 +909,17 @@ def person_name(params)
     'John Doe'
   end
 end
+
+#
+# You can also use Kind::Optional(<Type>) to achieve the same behavior
+#
+def person_name(params)
+  Kind::Optional(Hash)
+    .wrap(params)
+    .map { |data| data if data.values_at(:first_name, :last_name).compact.size == 2 }
+    .map { |data| "#{data[:first_name]} #{data[:last_name]}" }
+    .value_or { 'John Doe' }
+end
 ```
 
 > Note: You could use the `.as_optional` method (or it alias `.as_maybe`) with any [type checker](https://github.com/serradura/kind/blob/b177fed9cc2b3347d63963a2a2fd99f989c51a9a/README.md#type-checkers).
@@ -1025,18 +1038,18 @@ Kind::Optional(Numeric).wrap(5)
 
 ### 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.
+If you don't want to use `#map/#then` to access the value, you could use the `#try` method to access it. So, if the value wasn't `nil` or `Kind::Undefined`, the some monad will be returned.
 
 ```ruby
 object = 'foo'
 
-Kind::Maybe[object].try(:upcase) # "FOO"
+Kind::Maybe[object].try(:upcase).value # "FOO"
 
-Kind::Maybe[{}].try(:fetch, :number, 0) # 0
+Kind::Maybe[{}].try(:fetch, :number, 0).value # 0
 
-Kind::Maybe[{number: 1}].try(:fetch, :number) # 1
+Kind::Maybe[{number: 1}].try(:fetch, :number).value # 1
 
-Kind::Maybe[object].try { |value| value.upcase } # "FOO"
+Kind::Maybe[object].try { |value| value.upcase }.value # "FOO"
 
 #############
 # Nil value #
@@ -1044,9 +1057,9 @@ Kind::Maybe[object].try { |value| value.upcase } # "FOO"
 
 object = nil
 
-Kind::Maybe[object].try(:upcase) # nil
+Kind::Maybe[object].try(:upcase).value # nil
 
-Kind::Maybe[object].try { |value| value.upcase } # nil
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
 
 #########################
 # Kind::Undefined value #
@@ -1054,12 +1067,26 @@ Kind::Maybe[object].try { |value| value.upcase } # nil
 
 object = Kind::Undefined
 
-Kind::Maybe[object].try(:upcase) # nil
+Kind::Maybe[object].try(:upcase).value # nil
+
+Kind::Maybe[object].try { |value| value.upcase }.value # nil
+```
+
+> **Note:** You can use the `#try` method with `Kind::Optional` objects.
+
+[⬆️ Back to Top](#table-of-contents-)
+
+### Kind::Maybe#try!
+
+Has the same behavior of its `#try`, but it will raise an error if the value doesn't respond to the expected method.
+
+```ruby
+Kind::Maybe[{}].try(:upcase)  # => #<Kind::Maybe::None:0x0000... @value=nil>
 
-Kind::Maybe[object].try { |value| value.upcase } # nil
+Kind::Maybe[{}].try!(:upcase) # => NoMethodError (undefined method `upcase' for {}:Hash)
 ```
 
-> **Note:** You can use the try method with the `Kind::Optional`.
+> **Note:** You can also use the `#try!` method with `Kind::Optional` objects.
 
 [⬆️ Back to Top](#table-of-contents-)
 

data/lib/kind/maybe.rb

@@ -68,12 +68,14 @@ module Kind
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, &block)
+      def try!(method_name = Undefined, &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
 
@@ -92,22 +94,43 @@ module Kind
       def map(&fn)
         result = fn.call(@value)
 
-        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)
+        resolve(result)
       end
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, *args, &block)
-        fn = Undefined == method_name ? 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)

data/lib/kind/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura