monad-oxide 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ef9afae9321a36b11f966859ba1e031288d0c532f758e4f9b7063234ab8fe2a
-  data.tar.gz: 9c1e4528650956209644f9095db174b510a4277e79c96d11f137ef1bb1ed708c
+  metadata.gz: 7f4add1af70591ea0b72483b5608bb2c0e08d06d29d2c34dc2d952d501c9f632
+  data.tar.gz: c7a0d1d2a47c157faf8aa069425e37b11964b9dc81ff6d3329b51dd352350d51
 SHA512:
-  metadata.gz: 5270dd501e132f3396184508e05a1dc41e8ff119689a5a44a4b6c27bfcc4b23d5db18d53f8b5cdd68dc1915debe134ac27c8516fe143d165ba023414dbbc3d6f
-  data.tar.gz: 7badd118397b1bddc5a5c65b2e23f2c87e57d3c1ac10f774ee6863f3116aed9923f21d43693dbb1e4402128cd5c32e1640a7a8071c2083d29cfcdf977116ac9f
+  metadata.gz: 37c193a394b45179137bd13127c0907b9848fb87a116e81e9de5b821aca3e967e5559209861c6da200ea59bc30d35f1b1a8591cca0224a8cc617ccc5e39b3e01
+  data.tar.gz: fefeeef05166cee8ae902fec3af6e47d848dcacc3da0008bade58d896ca1d9e9846f8f549348b9834d4ba44cd63efa2eb912c4a8b8cbbb2315d9ac3fff035d74

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+################################################################################
+# Defines a helper for concurrent/promises.
+################################################################################
+
+require 'concurrent/promises'
+require_relative '../monad-oxide'
+
+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.
+  # @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,
+    )
+  end
+
+end

data/lib/{err.rb → monad-oxide/err.rb}

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module MonadOxide
   ##

data/lib/{left.rb → monad-oxide/left.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 ################################################################################
-#
+# Defines Left, a variant of Either.
 ################################################################################
 
 require_relative './error'

data/lib/{ok.rb → monad-oxide/ok.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './result'
 require_relative './error'
 

data/lib/{option.rb → monad-oxide/option.rb}

@@ -191,6 +191,30 @@ module MonadOxide
       raise OptionMethodNotImplementedError.new()
     end
 
+    ##
+    # Use pattern matching to work with both Some and None variants. This is
+    # useful when it is desirable to have both variants handled in the same
+    # location. It can also be useful when either variant can coerced into a
+    # non-Option type.
+    #
+    # Ruby has no built-in pattern matching, but the next best thing is a
+    # Hash using the Option classes themselves as the keys.
+    #
+    # Tests for this are found in Some and None's tests.
+    #
+    # @param matcher [Hash<Class, Proc<T, R>] matcher The matcher to match
+    # upon.
+    # @option matcher [Proc] MonadOxide::Some The branch to execute for Some.
+    # @option matcher [Proc] MonadOxide::None The branch to execute for None.
+    # @return [R] The return value of the executed Proc.
+    def match(matcher)
+      if self.kind_of?(None)
+        matcher[self.class].call()
+      else
+        matcher[self.class].call(@data)
+      end
+    end
+
   end
 
 end

data/lib/{right.rb → monad-oxide/right.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 ################################################################################
-#
+# Defines Right, a variant of Either.
 ################################################################################
 
 require_relative './error'

data/lib/{version.rb → 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.15.0'
+  VERSION='0.17.0'
 end

data/lib/monad-oxide.rb

@@ -1,14 +1,14 @@
-require_relative './result'
-require_relative './err'
-require_relative './ok'
-require_relative './either'
-require_relative './left'
-require_relative './right'
-require_relative './option'
-require_relative './some'
-require_relative './none'
-require_relative './array'
-require_relative './version'
+# frozen_string_literal: true
+require_relative './monad-oxide/result'
+require_relative './monad-oxide/err'
+require_relative './monad-oxide/ok'
+require_relative './monad-oxide/either'
+require_relative './monad-oxide/left'
+require_relative './monad-oxide/right'
+require_relative './monad-oxide/array'
+require_relative './monad-oxide/version'
+# Intentionally do not require helpers which inflict external dependencies, such
+# as ./concurrent-promises.rb which requires the 'concurrent' gem.
 
 ##
 # The top level module for the monad-oxide library. Of interest, @see `Result',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monad-oxide
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Logan Barnett
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-07 00:00:00.000000000 Z
+date: 2026-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: org-ruby
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Monad-Oxide is a port of Rust's built-in monads from std, such as Result and
   Option. This enables better reasoning about error handling and possibly missing
@@ -75,19 +89,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/array.rb
-- lib/either.rb
-- lib/err.rb
-- lib/error.rb
-- lib/left.rb
 - lib/monad-oxide.rb
-- lib/none.rb
-- lib/ok.rb
-- lib/option.rb
-- lib/result.rb
-- lib/right.rb
-- lib/some.rb
-- lib/version.rb
+- lib/monad-oxide/array.rb
+- lib/monad-oxide/concurrent-promises.rb
+- lib/monad-oxide/either.rb
+- lib/monad-oxide/err.rb
+- lib/monad-oxide/error.rb
+- lib/monad-oxide/left.rb
+- lib/monad-oxide/none.rb
+- lib/monad-oxide/ok.rb
+- lib/monad-oxide/option.rb
+- lib/monad-oxide/result.rb
+- lib/monad-oxide/right.rb
+- lib/monad-oxide/some.rb
+- lib/monad-oxide/version.rb
 homepage:
 licenses:
 - Apache-2.0