monad-oxide 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f4add1af70591ea0b72483b5608bb2c0e08d06d29d2c34dc2d952d501c9f632
-  data.tar.gz: c7a0d1d2a47c157faf8aa069425e37b11964b9dc81ff6d3329b51dd352350d51
+  metadata.gz: ffb60a419ac6559c096b5ed4b548a33c09181526ab2f7f4796468c3a207391d1
+  data.tar.gz: 5361aa132d7073416195fda40638a26a0072ff9852226472a3d964525adac17a
 SHA512:
-  metadata.gz: 37c193a394b45179137bd13127c0907b9848fb87a116e81e9de5b821aca3e967e5559209861c6da200ea59bc30d35f1b1a8591cca0224a8cc617ccc5e39b3e01
-  data.tar.gz: fefeeef05166cee8ae902fec3af6e47d848dcacc3da0008bade58d896ca1d9e9846f8f549348b9834d4ba44cd63efa2eb912c4a8b8cbbb2315d9ac3fff035d74
+  metadata.gz: 1973d9a47176e3e31ebf8c2e28feab104aaa7b65bdb08c874dd4a0d0c037d74b990b327394eb91965ba5245d78a2060d24bbc458e0b679435003187622c3e94f
+  data.tar.gz: b1ac8aebcb9173063d5bcdd25c59bc97bb2d1e36071024006ac3f7e77bbe82672a3710f551541dbb4688eef8088701d5ab391194f3bba667733ca78b44d70379

data/lib/monad-oxide/array.rb

@@ -2,23 +2,34 @@
 class Array
 
   ##
-  # Take an Array of Results and convert them to a single Result whose value is
-  # an Array of Ok or Err values. Ok Results will have only Ok values, and Err
-  # Results will have only Err values. A single Err in the input Array will
-  # convert the entire Result into an Err.
+  # Converts an Array into a single Result.  Returns Ok containing all values
+  # if every element succeeds, otherwise returns Err containing _any_ errors.
   #
-  # @return [MonadOxide::Result<Array<V>, Array<E>>] A Result whose value is an
-  # array of all of the Oks or Errs in the Array.
+  # Element interpretation:
+  # - Ok/Err Results: evaluated for success/failure.
+  # - Exceptions: treated as errors.
+  # - Other values: treated as successes.
+  #
+  # @return [MonadOxide::Result<Array<V>, Array<E>>] Ok with all values if
+  #   all succeed, or Err with all errors if any fail.
   def into_result()
     tracker = {
       oks: [],
       errs: [],
     }
-    self.each do |result|
-      result.match({
-        MonadOxide::Ok => ->(x) { tracker[:oks].push(x) },
-        MonadOxide::Err => ->(e) { tracker[:errs].push(e) },
-      })
+    self.each do |element|
+      (
+        element.is_a?(MonadOxide::Result) ?
+          element :
+          (element.is_a?(Exception) ?
+            MonadOxide.err(element) :
+            MonadOxide.ok(element)
+            )
+      )
+        .match({
+          MonadOxide::Ok => ->(x) { tracker[:oks].push(x) },
+          MonadOxide::Err => ->(e) { tracker[:errs].push(e) },
+        })
     end
     tracker[:errs].empty?() ?
       MonadOxide.ok(tracker[:oks]) :

data/lib/monad-oxide/concurrent-promises.rb

@@ -5,6 +5,7 @@
 
 require 'concurrent/promises'
 require_relative '../monad-oxide'
+require_relative './array'
 
 class Concurrent::Promises::Future
 
@@ -12,16 +13,27 @@ class Concurrent::Promises::Future
   # Coerces a Current::Promises::Future into a MonadOxide::Result.  This
   # behavior forces the Future to finalize, and thus is blocking behavior.
   # A successful Future becomes a MonadOxide::Ok, and a failed Future becomes a
-  # MonadOxide::Err.
+  # MonadOxide::Err.  If the Promise returns an Array of Results (either on the
+  # Err branch or the Ok branch), flatten them.
   # @return [MonadOxide::Result<A, E>] A coerced Result from the Future,
   # containing whatever value the Future was holding.
   def into_result()
     success, value, err = self.result()
-    success ? MonadOxide.ok(value) : MonadOxide.err(
-      # err isn't actually the error unless someone called rescue on the promise
-      # chain.  It's pretty weird.  So we have to check for both.
-      err.nil?() ? value : err,
+    (
+      success ? MonadOxide.ok(value) : MonadOxide.err(
+        err.nil?() ? value: err,
+      )
     )
+      .and_then(->(x) {
+        x.respond_to?(:into_result) ?
+          x.into_result() :
+          MonadOxide.ok(x)
+      })
+      .or_else(->(x) {
+        x.respond_to?(:into_result) ?
+          x.into_result() :
+          MonadOxide.err(x)
+      })
   end
 
 end

data/lib/monad-oxide/err.rb

@@ -20,14 +20,17 @@ module MonadOxide
     #
     # On a cursory search, this is not documented behavior.
     #
-    # @param x [Exception|T] The potential Exception to add a backtrace to, if
-    #                        it is missing a backtrace.
-    # @returns [Exception|T] The passed value, with a backtrace added if it is
-    #                        an Exception.
+    # @param x [Exception] The potential Exception to add a backtrace to, if
+    #                      it is missing a backtrace.
+    # @returns [Exception] The passed value, with a backtrace added if it is
+    #                      an Exception.  Non-Exceptions are wrapped in an
+    #                      Exception.
     def self.backtrace_fix(x)
-      if x.kind_of?(Exception) && x.backtrace.nil?
+      if  !x.kind_of?(Exception)
+        raise StandardError.new(x)
+      elsif x.kind_of?(Exception) && x.backtrace.nil?()
         raise x
-      else
+      else # Must be Exception with a backtrace already.
         x
       end
     rescue => e

data/lib/monad-oxide/version.rb

@@ -3,5 +3,5 @@ module MonadOxide
   # This version is locked to 0.x.0 because semver is a lie and this project
   # uses CICD to push new versions. Any commits that appear on main will result
   # in a new version of the gem created and published.
-  VERSION='0.17.0'
+  VERSION='0.18.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monad-oxide
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Logan Barnett
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-05 00:00:00.000000000 Z
+date: 2026-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: org-ruby