sorbet-result 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4721bbbd3c051fd826ebc2721567a032a6f64ffb7545c990cef2d5b82fd78305
-  data.tar.gz: bd1cf4a0d186f3ef0be4f8e8aba11908fe4e4546198a647e10140901f4c16069
+  metadata.gz: 55fcf298c304ef8f0101c1a6461c7ded68f9bfb87fead9d12ad23760b4d2268b
+  data.tar.gz: 96ee6aaac4f115f97065977d0cd21f510c9dcdab08b73f14855760171c3e5053
 SHA512:
-  metadata.gz: d767cc69f61e9de10862ff3ceca4a9fbf880eb748cb7fb12c58f992b6a573a566ea15b6d5867bd47b42eac6a890195d29bd79731de56ef7b1bee90c51d31691d
-  data.tar.gz: 52577942ef7db2a668b3d505263507758c6a720271ed9e883a346e962c48e53ba3b4850f3fffd590f4580ff2bfb352c08dc2f2d1e503c4c790b58f896ff84a3a
+  metadata.gz: 9a0e1ed605028d5d98109173d11a530a7f7025c33462a918ced64bf240e06e740f78371d5a249bc0866cfd4ac1ebeb4cfef2fe58e17a0cad2a8cfd6a646a5796
+  data.tar.gz: 454f9d376b8a1066aaa2cbbd350f20b43fc71c1ffece65cee72dc8299118260d2dfb0b5b38e73eb2427d9df6c6ce69e222e21243c32292d1a5859c6fcad3cfb9

data/CHANGELOG.md

@@ -6,6 +6,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1] - 2023-06-20
+
+### Added
+
+- Add `#on_error` to `Typed::Result` to allow behavior when an error is encountered during chaining.
+- Add `#payload_or` to `Typed::Result` to allow callers to specify a default value if `Failure` is returned.
+
 ## [0.3.0] - 2023-06-06
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-result (0.3.0)
+    sorbet-result (0.3.1)
       sorbet-runtime (~> 0.5)
       zeitwerk (~> 2.6)
 
@@ -17,11 +17,13 @@ GEM
     irb (1.7.0)
       reline (>= 0.3.0)
     json (2.6.3)
-    minitest (5.18.0)
+    minitest (5.18.1)
     netrc (0.11.0)
     parallel (1.23.0)
-    parser (3.2.2.1)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
     rainbow (3.1.1)
     rake (13.0.6)
     rbi (0.0.16)
@@ -29,14 +31,14 @@ GEM
       parser (>= 2.6.4.0)
       sorbet-runtime (>= 0.5.9204)
       unparser
-    regexp_parser (2.8.0)
+    regexp_parser (2.8.1)
     reline (0.3.5)
       io-console (~> 0.5)
     rexml (3.2.5)
-    rubocop (1.52.0)
+    rubocop (1.52.1)
       json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.2.0.0)
+      parser (>= 3.2.2.3)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
@@ -52,14 +54,14 @@ GEM
     rubocop-sorbet (0.7.0)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
-    sorbet (0.5.10864)
-      sorbet-static (= 0.5.10864)
-    sorbet-runtime (0.5.10864)
-    sorbet-static (0.5.10864-universal-darwin-22)
-    sorbet-static (0.5.10864-x86_64-linux)
-    sorbet-static-and-runtime (0.5.10864)
-      sorbet (= 0.5.10864)
-      sorbet-runtime (= 0.5.10864)
+    sorbet (0.5.10880)
+      sorbet-static (= 0.5.10880)
+    sorbet-runtime (0.5.10880)
+    sorbet-static (0.5.10880-universal-darwin-22)
+    sorbet-static (0.5.10880-x86_64-linux)
+    sorbet-static-and-runtime (0.5.10880)
+      sorbet (= 0.5.10880)
+      sorbet-runtime (= 0.5.10880)
     spoom (1.2.1)
       sorbet (>= 0.5.10187)
       sorbet-runtime (>= 0.5.9204)
@@ -75,7 +77,7 @@ GEM
       yard-sorbet
     thor (1.2.2)
     unicode-display_width (2.4.2)
-    unparser (0.6.7)
+    unparser (0.6.8)
       diff-lcs (~> 1.3)
       parser (>= 3.2.0)
     yard (0.9.34)

data/README.md

@@ -76,10 +76,11 @@ Finally, there are a few methods you can use on both `Typed::Result` types.
 ```ruby
 result = call_api(1)
 
-result.success? # => true if success, false if failure
-result.failure? # => true if failure, false if success
+result.success? # => true on success, false on failure
+result.failure? # => true on failure, false on success
 result.payload # => nil on failure, payload type on failure
 result.error # => nil on success, error type on failure
+result.payload_or("fallback") # => returns payload on success, given value on failure
 
 # You can combine all the above to write flow-sensitive type-checked code
 if result.success?
@@ -113,6 +114,19 @@ else
 end
 ```
 
+You can also use the `#on_error` chain to take an action only on failure, such as logging or capturing error information in an error monitoring service.
+
+```ruby
+# In this example, retrieve_user and send_notification both return a Typed::Result
+#  retrieve_user: Typed::Result[User, RetrieveUserError
+#  send_notification: Typed::Result[T::Boolean, SendNotificationError]
+res = retrieve_user(user_id)
+  .and_then { |user| send_notification(user.email) } # this block will only run if retrieve_user returns a Typed::Success
+  .on_error { |error| puts "Encountered this error: #{error}"}
+```
+
+If the above chain does not fail, the `puts` statement is never run. If the chain does yield a `Failure`, the `puts` block is executed and the `Failure` is ultimately returned.
+
 ## Why use Results?
 
 Let's say you're working on a method that reaches out to an API and fetches a resource. We hope to get a successful response and continue on in our program, but you can imagine several scenarios where we don't get that response: our authentication could fail, the server could return a 5XX response code, or the resource we were querying could have moved or not exist any more.

data/lib/typed/failure.rb

@@ -57,5 +57,25 @@ module Typed
     def and_then(&_block)
       self
     end
+
+    sig do
+      override
+        .params(block: T.proc.params(arg0: Error).void)
+        .returns(T.self_type)
+    end
+    def on_error(&block)
+      block.call(error)
+      self
+    end
+
+    sig do
+      override
+        .type_parameters(:Fallback)
+        .params(value: T.type_parameter(:Fallback))
+        .returns(T.any(Payload, T.type_parameter(:Fallback)))
+    end
+    def payload_or(value)
+      value
+    end
   end
 end

data/lib/typed/result.rb

@@ -32,5 +32,20 @@ module Typed
         .returns(T.any(Result[T.type_parameter(:U), T.type_parameter(:T)], Result[T.type_parameter(:U), Error]))
     end
     def and_then(&_block); end
+
+    sig do
+      abstract
+        .params(block: T.proc.params(arg0: Error).void)
+        .returns(T.self_type)
+    end
+    def on_error(&block); end
+
+    sig do
+      abstract
+        .type_parameters(:Fallback)
+        .params(value: T.type_parameter(:Fallback))
+        .returns(T.any(Payload, T.type_parameter(:Fallback)))
+    end
+    def payload_or(value); end
   end
 end

data/lib/typed/success.rb

@@ -57,5 +57,24 @@ module Typed
     def and_then(&block)
       block.call(payload)
     end
+
+    sig do
+      override
+        .params(_block: T.proc.params(arg0: Error).void)
+        .returns(T.self_type)
+    end
+    def on_error(&_block)
+      self
+    end
+
+    sig do
+      override
+        .type_parameters(:Fallback)
+        .params(_value: T.type_parameter(:Fallback))
+        .returns(T.any(Payload, T.type_parameter(:Fallback)))
+    end
+    def payload_or(_value)
+      payload
+    end
   end
 end