monad-oxide 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d3bac39b59ae39fbb179c1e3e5287eb88b7f5a216d50ada6c47684518dfc5a3
-  data.tar.gz: be044059a64fcb8d37748ac7a8d075e5b561979de784a4a468eda49d9c4dd29e
+  metadata.gz: a9e34a9c5d348e0d022e91919a9d4f8c3c3337cc4040e3c6003a21395db4a553
+  data.tar.gz: 589f27d397f02deddc8e4372fc1ddbf553803e301ed5cff6df176d7e0d740c79
 SHA512:
-  metadata.gz: a62b8508007f9c2577590bcc121806a98a824d66f21e7118f424de74996d864131840c69cd7b169168fa06c7ed1984da09602e322984fa6e9b85e6c50b76459f
-  data.tar.gz: 14db95535af73102b08f350f87337d3b424a737a9f6c76757ed695cb486c0637aa8a700512c78dc07c649d23489c52b14a1af49f36a149db1736502f50615355
+  metadata.gz: 30d113b3edff4cc76192203e038606d62cdb306fc4baf386b40ef60b6bef1eb6638d5b26c2a2f0496ca990c96a12ae902b8d92c55babcff74de385c24bf99c39
+  data.tar.gz: 58f34dc9b1d67dceb2c229f8f53fce8cf6f309a8625bbe267166840482f77001c511306cada76212b5f7022d6ed1fcffbf05d2d675ae51be186ff26bed16bce9

data/lib/err.rb

@@ -0,0 +1,155 @@
+
+module MonadOxide
+  ##
+  # Err is the error case for Result.
+  #
+  # Any methods in Result that would process a successful Result (Ok) will fall
+  # through with Err instances.
+  class Err < Result
+    ##
+    # Create an Err.
+    #
+    # If the Exception provided was not thrown (ie. created with Exception.new),
+    # it will not have a backtrace. The Err constructor takes care of this by
+    # raising the Exception and immediately capturing the Exception - this
+    # causes the backtrace to be populated and will be availabl to any cosumers
+    # automatically.
+    #
+    # @param data [Exception] This must be an Exception it will result in a
+    #                         TypeError.
+    # @raise [TypeError] Is raised if the input is not an Exception.
+    def initialize(data)
+      if !data.kind_of?(Exception)
+        raise TypeError.new("#{data.inspect} is not an Exception.")
+      else
+        begin
+          # Ruby Exceptions do not come with a backtrace. During the act of
+          # raising an Exception, that Exception is granted a backtrace. So any
+          # kind of `Exception.new()' invocations will have a `nil' value for
+          # `backtrace()'. To get around this, we can simply raise the Exception
+          # here, and then we get the backtrace we want.
+          #
+          # On a cursory search, this is not documented behavior.
+          if data.backtrace.nil?
+            raise data
+          else
+            @data = data
+          end
+        rescue => e
+          @data = e
+        end
+      end
+    end
+
+    ##
+    # Falls through. @see Result#and_then for how this is handled in either
+    # Result case, and @see Ok.and_then for how this is handled in the Ok case.
+    # @param f [Proc] Optional Proc - ignored.
+    # @yield An ignored block.
+    # @return [Err] This Err.
+    def and_then(f=nil, &block)
+      self
+    end
+
+    ##
+    # Applies `f' or the block over the `Exception' and returns the same `Err'.
+    # No changes are applied. This is ideal for logging.  Exceptions raised
+    # during these transformations will return an `Err' with the Exception.
+    # @param f [Proc<A=Exception>] The function to call. Could be a block
+    #          instead.  Takes an [A] the return is ignored.
+    # @yield Will yield a block that takes an A the return is ignored. Same as
+    #        `f' parameter.
+    # @return [Result<A, E>] returns self.
+    def inspect_err(f=nil, &block)
+      begin
+        (f || block).call(@data)
+        self
+      rescue => e
+        self.class.new(e)
+      end
+    end
+
+    ##
+    # Falls through. @see Result#inspect_ok for how this is handled in either
+    # Result case, and @see Ok.inspect_ok for how this is handled in the Ok
+    # case.
+    # @param f [Proc] Optional Proc - ignored.
+    # @yield An ignored block.
+    # @return [Err] This Err.
+    def inspect_ok(f=nil, &block)
+      self
+    end
+
+    ##
+    # Falls through. @see Result#map for how this is handled in either
+    # Result case, and @see Ok.map for how this is handled in the Ok case.
+    # @param f [Proc] Optional Proc - ignored.
+    # @yield An ignored block.
+    # @return [Err] This Err.
+    def map(f=nil, &block)
+      self
+    end
+
+    ##
+    # Applies `f' or the block over the data and returns a new new `Err' with
+    # the returned value.
+    # @param f [Proc<A, B>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and returns a B.
+    # @yield Will yield a block that takes an A and returns an Err<B>. Same as
+    #        `f' parameter.
+    # @return [Result<B>] A new `Err<B>' whose `B' is the return of `f' or the
+    #         block. Errors raised when applying `f' or the block will result in
+    #         a returned `Err<Exception>'.
+    def map_err(f=nil, &block)
+      begin
+        self.class.new((f || block).call(@data))
+      rescue => e
+        self.class.new(e)
+      end
+    end
+
+    ##
+    # Invokes `f' or the block with the data and returns the Result returned
+    # from that. Exceptions raised during `f' or the block will return an
+    # `Err<Exception>'. The return type is enforced.
+    # @param f [Proc<A, Result<B>>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and must return a [Result<B>].
+    # @yield Will yield a block that takes an A and returns a Result<B>. Same as
+    #        `f' parameter.
+    # @return [Err<C> | Err<Exception>] A new Result from `f' or the block.
+    #         Exceptions raised will result in `Err<Exception>'. If `f' returns
+    #         a non-Result, this will return `Err<ResultReturnExpectedError>'.
+    def or_else(f=nil, &block)
+      begin
+        r = (f || block).call(@data)
+        # Enforce that we always get a Result. Without a Result, coerce to an
+        # Err.
+        if !r.kind_of?(Result)
+          raise ResultReturnExpectedError.new(r)
+        else
+          r
+        end
+      rescue => e
+        Err.new(e)
+      end
+    end
+
+    ##
+    # Dangerously try to access the `Result' data. If this is an `Err', an
+    # exception will be raised. It is recommended to use this for tests only.
+    # @return [A] The inner data of this `Result'.
+    def unwrap()
+      raise UnwrapError.new(
+        "#{self.class} with #{@data.inspect} could not be unwrapped as an Ok.",
+      )
+    end
+
+    ##
+    # Dangerously access the `Err' data. If this is an `Ok', an exception will
+    # be raised. It is recommended to use this for tests only.
+    # @return [E] The `Exception' of this `Err'.
+    def unwrap_err()
+      @data
+    end
+  end
+end

data/lib/monad-oxide.rb

@@ -0,0 +1,27 @@
+require_relative './result'
+require_relative './err'
+require_relative './ok'
+require_relative './version'
+
+##
+# The top level module for the monad-oxide library. Of interest, @see `Result',
+# @see `Err', and @see `Ok'.
+module MonadOxide
+  module_function
+
+  ##
+  # Create an `Err' as a conveniece method.
+  # @param data [Exception] The `Exception' for this `Err'.
+  # @return [Result<A, E=Exception>] the `Err' from the provided `Exception'.
+  def err(data)
+    MonadOxide::Err.new(data)
+  end
+
+  ##
+  # Create an `Ok' as a conveniece method.
+  # @param data [Object] The inner data for this `Ok'.
+  # @return [Result<A, E=Exception>] the `Ok' from the provided inner data.
+  def ok(data)
+    MonadOxide::Ok.new(data)
+  end
+end

data/lib/ok.rb

@@ -0,0 +1,127 @@
+require_relative './result'
+
+module MonadOxide
+  ##
+  # `Ok' represents a success `Result'. For most operations, `Ok' will perform
+  # some operation. Exceptions raised during calls to `Ok' will coerce the chain
+  # into `Err', which generally causes execution to fall through the entire
+  # chain.
+  class Ok < Result
+    ##
+    # Constructs an `Ok' with the data provided.
+    # @param data [Object] The inner data this Result encapsulates.
+    def initialize(data)
+      @data = data
+    end
+
+    ##
+    # Invokes `f' or the block with the data and returns the Result returned
+    # from that. Exceptions raised during `f' or the block will return an
+    # `Err<Exception>'. The return type is enforced.
+    # @param f [Proc<A, Result<B>>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and must return a [Result<B>].
+    # @yield Will yield a block that takes an A and returns a Result<B>. Same as
+    #        `f' parameter.
+    # @return [Ok<B> | Err<C>] A new Result from `f' or the block. Exceptions
+    #         raised will result in `Err<C>'. If `f' returns a non-Result, this
+    #         will return `Err<ResultReturnExpectedError>'.
+    def and_then(f=nil, &block)
+      begin
+        r = (f || block).call(@data)
+        # Enforce that we always get a Result. Without a Result, coerce to an
+        # Err.
+        if !r.kind_of?(Result)
+          raise ResultReturnExpectedError.new(r)
+        else
+          r
+        end
+      rescue => e
+        Err.new(e)
+      end
+    end
+
+    ##
+    # Falls through. @see Result#inspect_err for how this is handled in either
+    # Result case, and @see Err.inspect_err for how this is handled in the Err
+    # case.
+    # @param f [Proc] Optional Proc - ignored.
+    # @yield An ignored block.
+    # @return [Ok] This Ok.
+    def inspect_err(f=nil, &block)
+      self
+    end
+
+    ##
+    # Applies `f' or the block over the data and returns the same `Ok'. No
+    # changes are applied. This is ideal for logging.  Exceptions raised during
+    # these transformations will return an `Err' with the Exception.
+    # @param f [Proc<A, B>] The function to call. Could be a block instead.
+    #          Takes an [A] the return is ignored.
+    # @yield Will yield a block that takes an A the return is ignored. Same as
+    #        `f' parameter.
+    # @return [Result<A>] returns self.
+    def inspect_ok(f=nil, &block)
+      begin
+        (f || block).call(@data)
+        self
+      rescue => e
+        Err.new(e)
+      end
+    end
+
+    ##
+    # Applies `f' or the block over the data and returns a new new `Ok' with the
+    # returned value.
+    # @param f [Proc<A, B>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and returns a B.
+    # @yield Will yield a block that takes an A and returns a B. Same as
+    #        `f' parameter.
+    # @return [Result<B>] A new `Ok<B>' whose `B' is the return of `f' or the
+    #         block. Errors raised when applying `f' or the block will result in
+    #         a returned `Err<Exception>'.
+    def map(f=nil, &block)
+      begin
+        self.class.new((f || block).call(@data))
+      rescue => e
+        Err.new(e)
+      end
+    end
+
+    ##
+    # This is a no-op for Ok. @see Err#map_err.
+    # @param f [Proc<A, B>] A dummy function. Not used.
+    # @yield A dummy block. Not used.
+    # @return [Result<A>] This `Ok'.
+    def map_err(f=nil, &block)
+      self
+    end
+
+    ##
+    # The Err equivalent to Ok#and_then. This is a no-op for Ok. @see
+    # Err#or_else.
+    # @param f [Proc<A, B>] A dummy function. Not used.
+    # @yield A dummy block. Not used.
+    # @return [Result<A>] This `Ok'.
+    def or_else(f=nil, &block)
+      self
+    end
+
+    ##
+    # Dangerously access the `Ok' data. If this is an `Err', an exception will
+    # be raised. It is recommended to use this for tests only.
+    # @return [A] The inner data of this `Ok'.
+    def unwrap()
+      @data
+    end
+
+    ##
+    # Dangerously access the `Err' data. If this is an `Ok', an exception will
+    # be raised. It is recommended to use this for tests only.
+    # @return [E] The `Exception' of this `Err'.
+    def unwrap_err()
+      raise UnwrapError.new(
+        "#{self.class} with #{@data.inspect} could not be unwrapped as an Err.",
+      )
+    end
+  end
+end

data/lib/result.rb

@@ -0,0 +1,209 @@
+module MonadOxide
+  ##
+  # All errors in monad-oxide should inherit from this error. This makes it easy
+  # to handle library-wide errors on the consumer side.
+  class MonadOxideError < StandardError; end
+
+  ##
+  # Thie Exception signals an area under construction, or somehow the consumer
+  # wound up with a `Result' and not one of its subclasses (@see Ok and @see
+  # Err). Implementors of new methods on `Ok' and `Err' should create methods on
+  # `Result' as well which immediately raise this `Exception'.
+  class ResultMethodNotImplementedError < MonadOxideError; end
+
+  ##
+  # This `Exception' is produced when a method that expects the function or
+  # block to provide a `Result' but was given something else. Generally this
+  # Exception is not raised, but instead converts the Result into a an Err.
+  # Example methods with this behavior are Result#and_then and Result#or_else.
+  class ResultReturnExpectedError < MonadOxideError
+    ##
+    # The transformation expected a `Result' but got something else.
+    # @param data [Object] Whatever we got that wasn't a `Result'.
+    def initialize(data)
+      super("A Result was expected but got #{data.inspect}.")
+      data = @data
+    end
+    attr_reader(:data)
+  end
+
+  ##
+  # This `Exception' is raised when the consumer makes a dangerous wager
+  # about which state the `Result' is in, and lost. More specifically: An `Ok'
+  # cannot unwrap an Exception, and an `Err' cannot unwrap the `Ok' data.
+  class UnwrapError < MonadOxideError; end
+
+  ##
+  # A Result is a chainable series of sequential transformations. The Result
+  # structure contains an `Ok<A> | Err<Exception>`. This is the central location
+  # for documentation between both `Ok` and `Err`. It is best to think of any
+  # given `Ok` or `Err` as a `Result` instead. All methods on `Ok` are present
+  # on `Err` and vice versa. This way we can interchange one for the other
+  # during virtually any call.
+  #
+  # This is a base-class only, and you should never see instances of these in
+  # the wild.
+  class Result
+    # None of these work.
+    # Option 1:
+    # private_class_method :new
+    # Option 2:
+    # class << self
+    #   protected :new
+    # end
+
+    def initialize(data)
+      raise NoMethodError.new('Do not use Result directly. See Ok and Err.')
+    end
+
+    ##
+    # Un-nest this `Result'. This implementation is shared between `Ok' and
+    # `Err'. In both cases, the structure's data is operated upon.
+    # @return [Result] If `A' is a `Result' (meaning this `Result` is nested),
+    # return the inner-most `Result', regardless of the depth of nesting.
+    # Otherwise return `self'.
+    def flatten()
+      if @data.kind_of?(Result)
+        return @data.flatten()
+      else
+        self
+      end
+    end
+
+    ##
+    # For `Ok', invokes `f' or the block with the data and returns the Result
+    # returned from that. Exceptions raised during `f' or the block will return
+    # an `Err<Exception>'.
+    #
+    # For `Err', returns itself and the function/block are ignored.
+    #
+    # This method is used for control flow based on `Result' values.
+    #
+    # `and_then' is desirable for chaining together other Result based
+    # operations, or doing transformations where flipping from an `Ok' to an
+    # `Err' is desired. In cases where there is little/no risk of an `Err'
+    # state, @see Result#map.
+    #
+    # The `Err' equivalent operation is @see Result#or_else.
+    #
+    # The return type is enforced.
+    #
+    # @param f [Proc<A, Result<B>>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and must return a [Result<B>].
+    # @yield Will yield a block that takes an A and returns a Result<B>. Same as
+    #        `f' parameter.
+    # @return [Ok<B> | Err<C>] A new Result from `f' or the block. Exceptions
+    #         raised will result in `Err<C>'. If `f' returns a non-Result, this
+    #         will return `Err<ResultReturnExpectedError>'.
+    def and_then(f=nil, &block)
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # In the case of `Ok', applies `f' or the block over the data and returns a
+    # new new `Ok' with the returned value. For `Err', this method falls
+    # through. Exceptions raised during these transformations will return an
+    # `Err' with the Exception.
+    # @param f [Proc<A, B>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and returns a B.
+    # @yield Will yield a block that takes an A and returns a B. Same as
+    #        `f' parameter.
+    # @return [Result<B>] A new `Result<B>' whose `B' is the return of `f' or
+    #         the block. Errors raised when applying `f' or the block will
+    #         result in a returned `Err<Exception>'.
+    def map(f=nil, &block)
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # In the case of `Err', applies `f' or the block over the `Exception' and
+    # returns a new new `Err' with the returned value. For `Ok', this method
+    # falls through. Exceptions raised during these transformations will return
+    # an `Err' with the Exception.
+    # @param f [Proc<A, B>] The function to call. Could be a block
+    #          instead. Takes an [A=Exception] and returns a [B=Exception].
+    # @yield Will yield a block that takes an A and returns a B. Same as
+    #        `f' parameter.
+    # @return [Result<B>] A new `Result<A, ErrorB>' whose `ErrorB' is the return
+    #         of `f' or the block. Errors raised when applying `f' or the block
+    #         will result in a returned `Err<Exception>'.
+    def map_err(f=nil, &block)
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # In the case of `Err', applies `f' or the block over the `Exception' and
+    # returns the same `Err'. No changes are applied. This is ideal for logging.
+    # For `Ok', this method falls through. Exceptions raised during these
+    # transformations will return an `Err' with the Exception.
+    # @param f [Proc<A, B>] The function to call. Could be a block instead.
+    #          Takes an [A=Exception] the return is ignored.
+    # @yield Will yield a block that takes an A the return is ignored. Same as
+    #        `f' parameter.
+    # @return [Result<A>] returns self.
+    def inspect_err(f=nil, &block)
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # In the case of `Ok', applies `f' or the block over the data and returns
+    # the same `Ok'. No changes are applied. This is ideal for logging.  For
+    # `Err', this method falls through. Exceptions raised during these
+    # transformations will return an `Err' with the Exception.
+    # @param f [Proc<A, B>] The function to call. Could be a block instead.
+    #          Takes an [A] the return is ignored.
+    # @yield Will yield a block that takes an A the return is ignored. Same as
+    #        `f' parameter.
+    # @return [Result<A>] returns self.
+    def inspect_ok(f=nil, &block)
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # For `Err', invokes `f' or the block with the data and returns the Result
+    # returned from that. Exceptions raised during `f' or the block will return
+    # an `Err<Exception>'.
+    #
+    # For `Ok', returns itself and the function/block are ignored.
+    #
+    # This method is used for control flow based on `Result' values.
+    #
+    # `or_else' is desirable for chaining together other Result based
+    # operations, or doing transformations where flipping from an `Ok' to an
+    # `Err' is desired. In cases where there is little/no risk of an `Err'
+    # state, @see Result#map.
+    #
+    # The `Ok' equivalent operation is @see Result#and_then.
+    #
+    # The return type is enforced.
+    #
+    # @param f [Proc<A, Result<B>>] The function to call. Could be a block
+    #          instead. Takes an [A=Object] and must return a [Result<B>].
+    # @yield Will yield a block that takes an A and returns a Result<B>. Same as
+    #        `f' parameter.
+    # @return [Ok<B> | Err<C>] A new Result from `f' or the block. Exceptions
+    #         raised will result in `Err<C>'. If `f' returns a non-Result, this
+    #         will return `Err<ResultReturnExpectedError>'.
+    def or_else(f=nil, &block)
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # Dangerously access the `Result' data. If this is an `Err', an exception
+    # will be raised. It is recommended to use this for tests only.
+    # @raise [UnwrapError] if called on an `Err'.
+    # @return [A] - The inner data of this `Ok'.
+    def unwrap()
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+
+    ##
+    # Dangerously access the `Result' data. If this is an `Ok', an exception
+    # will be raised. It is recommended to use this for tests only.
+    # @raise [UnwrapError] if called on an `Ok'.
+    # @return [E] - The inner data of this `Err'.
+    def unwrap_err()
+      Err.new(ResultMethodNotImplementedError.new())
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+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.3.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monad-oxide
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Logan Barnett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-23 00:00:00.000000000 Z
+date: 2022-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: org-ruby
@@ -75,9 +75,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/err_spec.rb
-- lib/ok_spec.rb
-- lib/result_spec.rb
+- lib/err.rb
+- lib/monad-oxide.rb
+- lib/ok.rb
+- lib/result.rb
+- lib/version.rb
 homepage: 
 licenses:
 - Apache-2.0

data/lib/err_spec.rb

@@ -1,300 +0,0 @@
-require 'monad-oxide'
-require 'ok'
-require 'err'
-
-describe MonadOxide::Err do
-
-  # The constructor tests (MonadOxide::Err.new()) are exactly the same as the
-  # helper (MonadOxide.err()).
-  ctor_tests = ->(ctor) {
-    it 'raises a TypeError if not provided an Exception' do
-      expect { ctor.call('foo') }.to raise_error(TypeError)
-    end
-
-    it 'establishes a backtrace for unraised Exceptions' do
-      expect(
-        ctor.call(StandardError.new('foo'))
-          .unwrap_err()
-          .backtrace()
-      ).not_to(be_nil())
-    end
-
-    it 'retains backtraces for raised Exceptions' do
-      begin
-        raise StandardError.new('foo')
-      rescue => e
-        expect(
-          ctor.call(e)
-            .unwrap_err()
-            .backtrace()
-        ).to(be(e.backtrace()))
-      end
-    end
-  }
-
-  context '#initialize' do
-    ctor_tests.call(MonadOxide::Err.method(:new))
-  end
-
-  context 'MonadOxide.err' do
-    ctor_tests.call(MonadOxide.method(:err))
-  end
-
-  context '#and_then' do
-
-    context 'with blocks' do
-      it 'does nothing with the block' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .and_then() {|s| effected = "effect: #{s}"}
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .and_then() { 'bar' }
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-    end
-
-    context 'with Procs' do
-      it 'does nothing with the function' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .and_then(->(s) { effected = "effect: #{s}"})
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .and_then(->(_) { 'bar' })
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-    end
-
-  end
-
-
-  context '#inspect_err' do
-    context 'with blocks' do
-      it 'applies the data to the block provided' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .inspect_err(->(s) { effected = "effect: #{s}"})
-        expect(effected).to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .inspect_err() {|_| 'bar' }
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-
-      it 'returns an Err with the error from the block' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .inspect_err() {|_| raise StandardError.new('flagrant') }
-            .unwrap_err()
-            .message()
-          ).to(eq('flagrant'))
-      end
-    end
-
-    context 'with Procs' do
-      it 'applies the data to the function provided' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .inspect_err(->(s) { effected = "effect: #{s}"})
-        expect(effected).to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .inspect_err(->(_) { 'bar' })
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-
-      it 'returns an Err with the error from the function' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .inspect_err(->(_) { raise StandardError.new('flagrant') })
-            .unwrap_err()
-            .message()
-          ).to(eq('flagrant'))
-      end
-    end
-  end
-
-  context '#inspect_ok' do
-    context 'with blocks' do
-      it 'does nothing with the block' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .inspect_ok() {|s| effected = "effect: #{s}"}
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .inspect_ok() { 'bar' }
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-    end
-
-    context 'with Procs' do
-      it 'does nothing with the function' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .inspect_ok(->(s) { effected = "effect: #{s}"})
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .inspect_ok(->(_) { 'bar' })
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-    end
-  end
-
-
-  context '#map' do
-    context 'with blocks' do
-      it 'does nothing with the block' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .map() {|s| effected = "effect: #{s}"}
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map() { 'bar' }
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-    end
-
-    context 'with Procs' do
-      it 'does nothing with the function' do
-        effected = 'unset'
-        MonadOxide.err(StandardError.new('foo'))
-          .map(->(s) { effected = "effect: #{s}"})
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map(->(_) { 'bar' })
-            .unwrap_err()
-            .message()
-          ).to(eq('foo'))
-      end
-    end
-  end
-
-  context '#map_err' do
-    context 'with blocks' do
-      it 'returns an Err if an error is raised in the block' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err() {|_| raise StandardError.new('bar') }
-            .unwrap_err()
-            .message()
-          ).to(eq('bar'))
-      end
-
-      it 'returns a new Err' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err() {|_| StandardErr.new('bar') }
-            .class()
-          ).to(be(MonadOxide::Err))
-      end
-
-      it 'applies the block to the data for the new Ok' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err() {|e| StandardError.new(e.message() + 'bar') }
-            .unwrap_err()
-            .message()
-          ).to(eq('foobar'))
-      end
-
-      it 'requires the mapped value is an Exception still' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err() {|_| 'bar'}
-            .unwrap_err()
-            .class()
-          ).to(be(TypeError))
-      end
-    end
-
-    context 'with Procs' do
-      it 'returns an Err if an error is raised in the function' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err(->(_) { raise StandardError.new })
-            .unwrap_err()
-            .class()
-          ).to(be(StandardError))
-      end
-
-      it 'applies the function to the data for the new Ok' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err(->(e) { StandardError.new(e.message() + 'bar') })
-            .unwrap_err()
-            .message()
-          ).to(eq('foobar'))
-      end
-
-      it 'requires the mapped value is an Exception still' do
-        expect(
-          MonadOxide.err(StandardError.new('foo'))
-            .map_err(->(_) { 'bar' })
-            .unwrap_err()
-            .class()
-          ).to(be(TypeError))
-      end
-    end
-  end
-
-  context '#unwrap' do
-    it 'raises an UnwrapError' do
-      expect {
-        MonadOxide.err(StandardError.new('foo')).unwrap()
-      }.to(raise_error(MonadOxide::UnwrapError))
-    end
-  end
-
-  context '#unwrap_err' do
-    it 'provides the underlying value' do
-      expect(
-        MonadOxide.err(StandardError.new('foo')).unwrap_err().message(),
-      ).to(eq('foo'))
-    end
-  end
-end

data/lib/ok_spec.rb

@@ -1,347 +0,0 @@
-require 'monad-oxide'
-require 'ok'
-require 'err'
-
-describe MonadOxide::Ok do
-
-  context '#and_then' do
-
-    context 'with blocks' do
-      it 'passes the data from the Ok to the block' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then() {|s| MonadOxide.ok(s + 'bar') }
-            .unwrap()
-        ).to(eq('foobar'))
-      end
-
-      it 'converts to an Err if the block raises an error' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then() {|_| raise StandardError.new('flagrant') }
-            .class
-        ).to(be(MonadOxide::Err))
-      end
-
-      it 'converts to an Err if the block returns a non-Result' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then() {|_| 'bar' }
-            .class()
-        ).to(be(MonadOxide::Err))
-      end
-
-      it 'provides a ResultReturnExpectedError in the Err for non-Result returns' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then() {|_| 'bar' }
-            .unwrap_err()
-            .class()
-        ).to(be(MonadOxide::ResultReturnExpectedError))
-      end
-
-      it 'returns the same Ok returned by the block' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then() {|_| MonadOxide.ok('bar') }
-            .unwrap()
-        ).to(eq('bar'))
-      end
-
-      it 'returns the same Err returned by the block' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then() {|_| MonadOxide.err(StandardError.new()) }
-            .unwrap_err()
-            .class()
-        ).to(be(StandardError))
-      end
-    end
-
-    context 'with Procs' do
-      it 'passes the data from the Ok to the function' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then(->(s) { MonadOxide.ok(s + 'bar') })
-            .unwrap()
-        ).to(eq('foobar'))
-      end
-
-      it 'converts to an Err if the function raises an error' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then(->(_) { raise StandardError.new('flagrant') })
-            .class
-        ).to(be(MonadOxide::Err))
-      end
-
-      it 'converts to an Err if the function returns a non-Result' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then(->(_) { 'bar' })
-            .class()
-        ).to(be(MonadOxide::Err))
-      end
-
-      it 'provides a ResultReturnExpectedError in the Err for non-Result returns' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then(->(_) { 'bar' })
-            .unwrap_err()
-            .class()
-        ).to(be(MonadOxide::ResultReturnExpectedError))
-      end
-
-      it 'returns the same Ok returned by the function' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then(->(_) { MonadOxide.ok('bar') })
-            .unwrap()
-        ).to(eq('bar'))
-      end
-
-      it 'returns the same Err returned by the function' do
-        expect(
-          MonadOxide.ok('foo')
-            .and_then(->(_) { MonadOxide.err(StandardError.new()) })
-            .unwrap_err()
-            .class()
-        ).to(be(StandardError))
-      end
-
-    end
-
-  end
-
-  context '#map' do
-    context 'with blocks' do
-      it 'returns an Err if an error is raised in the block' do
-        expect(
-          MonadOxide.ok('foo')
-            .map() {|_| raise StandardError.new('bar') }
-            .unwrap_err()
-            .class()
-          ).to(be(StandardError))
-      end
-
-      it 'returns a new Ok' do
-        expect(
-          MonadOxide.ok('foo')
-            .map() {|_| 'bar' }
-            .class()
-          ).to(be(MonadOxide::Ok))
-      end
-
-      it 'applies the block to the data for the new Ok' do
-        expect(
-          MonadOxide.ok('foo')
-            .map() {|s| s + 'bar' }
-            .unwrap()
-          ).to(eq('foobar'))
-      end
-
-      it 'allows nesting of Ok' do
-        expect(
-          MonadOxide.ok('foo')
-            .map() {|s| MonadOxide.ok(s) }
-            .unwrap()
-            .class()
-          ).to(be(MonadOxide::Ok))
-      end
-
-      it 'allows nesting of Err' do
-        expect(
-          MonadOxide.ok('foo')
-            .map() {|_| MonadOxide.err(StandardError.new('bar')) }
-            .unwrap()
-            .class()
-          ).to(be(MonadOxide::Err))
-      end
-    end
-
-    context 'with Procs' do
-      it 'returns an Err if an error is raised in the function' do
-        expect(
-          MonadOxide.ok('foo')
-            .map(->(_) { raise StandardError.new })
-            .unwrap_err()
-            .class()
-          ).to(be(StandardError))
-      end
-
-      it 'returns a new Ok' do
-        expect(
-          MonadOxide.ok('foo')
-            .map(->(_) { 'bar' })
-            .class()
-          ).to(be(MonadOxide::Ok))
-      end
-
-      it 'applies the function to the data for the new Ok' do
-        expect(
-          MonadOxide.ok('foo')
-            .map(->(s) { s + 'bar' })
-            .unwrap()
-          ).to(eq('foobar'))
-      end
-
-      it 'allows nesting of Ok' do
-        expect(
-          MonadOxide.ok('foo')
-            .map(->(s) { MonadOxide.ok(s) })
-            .unwrap()
-            .class()
-          ).to(be(MonadOxide::Ok))
-      end
-
-      it 'allows nesting of Err' do
-        expect(
-          MonadOxide.ok('foo')
-            .map(->(_) { MonadOxide.err(StandardError.new()) })
-            .unwrap()
-            .class()
-          ).to(be(MonadOxide::Err))
-      end
-    end
-  end
-
-  context '#map_err' do
-    context 'with blocks' do
-      it 'does nothing with the block' do
-        effected = 'unset'
-        MonadOxide.ok('foo')
-          .map_err() {|s| effected = "effect: #{s}"}
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.ok('foo')
-            .map_err() { 'bar' }
-            .unwrap()
-          ).to(eq('foo'))
-      end
-    end
-
-    context 'with Procs' do
-      it 'does nothing with the function' do
-        effected = 'unset'
-        MonadOxide.ok('foo')
-          .map_err(->(s) { effected = "effect: #{s}"})
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.ok('foo')
-            .map_err(->(_) { 'bar' })
-            .unwrap()
-          ).to(eq('foo'))
-      end
-    end
-  end
-
-  context '#inspect_err' do
-    context 'with blocks' do
-      it 'does nothing with the block' do
-        effected = 'unset'
-        MonadOxide.ok('foo')
-          .inspect_err() {|s| effected = "effect: #{s}"}
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.ok('foo')
-            .inspect_err() { 'bar' }
-            .unwrap()
-          ).to(eq('foo'))
-      end
-    end
-
-    context 'with Procs' do
-      it 'does nothing with the function' do
-        effected = 'unset'
-        MonadOxide.ok('foo')
-          .inspect_err(->(s) { effected = "effect: #{s}"})
-        expect(effected).not_to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.ok('foo')
-            .inspect_err(->(_) { 'bar' })
-            .unwrap()
-          ).to(eq('foo'))
-      end
-    end
-  end
-
-  context '#inspect_ok' do
-    context 'with blocks' do
-      it 'applies the data to the block provided' do
-        effected = 'unset'
-        MonadOxide.ok('foo')
-          .inspect_ok(->(s) { effected = "effect: #{s}"})
-        expect(effected).to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.ok('foo')
-            .inspect_ok() {|_| 'bar' }
-            .unwrap()
-          ).to(eq('foo'))
-      end
-
-      it 'returns an Err with the error from the block' do
-        expect(
-          MonadOxide.ok('foo')
-            .inspect_ok() {|_| raise StandardError.new('flagrant') }
-            .unwrap_err()
-            .class()
-          ).to(be(StandardError))
-      end
-    end
-
-    context 'with Procs' do
-      it 'applies the data to the function provided' do
-        effected = 'unset'
-        MonadOxide.ok('foo')
-          .inspect_ok(->(s) { effected = "effect: #{s}"})
-        expect(effected).to(eq('effect: foo'))
-      end
-
-      it 'does not change the underlying data' do
-        expect(
-          MonadOxide.ok('foo')
-            .inspect_ok(->(_) { 'bar' })
-            .unwrap()
-          ).to(eq('foo'))
-      end
-
-      it 'returns an Err with the error from the function' do
-        expect(
-          MonadOxide.ok('foo')
-            .inspect_ok(->(_) { raise StandardError.new('flagrant') })
-            .unwrap_err()
-            .class()
-          ).to(be(StandardError))
-      end
-    end
-  end
-
-  context '#unwrap' do
-    it 'provides the underlying value' do
-      expect(MonadOxide.ok('foo').unwrap()).to(eq('foo'))
-    end
-  end
-
-  context '#unwrap_err' do
-    it 'raises an UnwrapError' do
-      expect {
-        MonadOxide.ok('foo').unwrap_err()
-      }.to(raise_error(MonadOxide::UnwrapError))
-    end
-  end
-end

data/lib/result_spec.rb

@@ -1,30 +0,0 @@
-require 'monad-oxide'
-require 'result'
-
-describe MonadOxide::Result do
-  context '#initialize' do
-    it 'is protected from external consumption' do
-      expect { MonadOxide::Result.new('hi') }.to(raise_exception(NoMethodError))
-    end
-  end
-
-  context '#flatten' do
-    it 'returns itself when the Result is already flat' do
-      r = MonadOxide.ok('flat')
-      expect(r.flatten()).to(be(r))
-    end
-
-    it 'returns the inner result' do
-      inner = MonadOxide.ok('inner')
-      outer = MonadOxide.ok(inner)
-      expect(outer.flatten()).to(be(inner))
-    end
-
-    it 'returns the innermost result regardless of nesting' do
-      innermost = MonadOxide.ok('innermost')
-      inner = MonadOxide.ok(innermost)
-      outer = MonadOxide.ok(inner)
-      expect(outer.flatten()).to(be(innermost))
-    end
-  end
-end