monad-oxide 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c37567d8988443ab1076e07e5784fa454f430a12400acbb15526de2164a2686
-  data.tar.gz: a09be57539e071b3094b1d052cff724f0b71e8ae22ecd3ed151ffc355984b041
+  metadata.gz: 12758d7a4698325f9f371dd587d52879bcb2088c89f6691600e56d4525d428a5
+  data.tar.gz: a7fad1a246adc14c63fcc1ac4d9c1f4e01b658b0077b0eb058218822eadcc9a8
 SHA512:
-  metadata.gz: a0b562a479e20ec1f488fe476c60c1c7138aa62f67b9cb83ca526ce0ff4e97a8c193d75062a175a466e877ae27b163ab9162cf72352126122035aa397024ac88
-  data.tar.gz: a78393ad99ebe353b9a9ccdbc31756e87a9578e768fa4b47fbef1bd756b08baa131b52ff69129a502d503e40daa44df283b678ec0ac26f5738b3bce562f003c9
+  metadata.gz: ebdc0c265cd9a2dfaef992c75fbb62675608fe74247e9fc00cb67201c6b6280999104d72926755990b38ab6b8ad1b5d20c3be9899446c787cf7765222129fce3
+  data.tar.gz: e27ae5ed41c7fed7f7fb90afc6a43b1165aeb41daf1295f756428cbf77a782f9210e33766b15ad973fae9760752cdcaa4d6ac96f53e9b34abbe63798da0ac2d4

data/lib/err.rb

@@ -65,6 +65,17 @@ module MonadOxide
       self
     end
 
+    ##
+    # Identifies that this is an `Err`.
+    # For counterparts:
+    # @see MonadOxide::Ok#ok?
+    # @see MonadOxide::Ok#err?
+    # @see MonadOxide::Err#ok?
+    # @return [Boolean] `true` because this is an `Err`.
+    def err?()
+      true
+    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
@@ -122,6 +133,17 @@ module MonadOxide
       end
     end
 
+    ##
+    # Identifies that this is not an `Ok`.
+    # For counterparts:
+    # @see MonadOxide::Ok#ok?
+    # @see MonadOxide::Ok#err?
+    # @see MonadOxide::Err#err?
+    # @return [Boolean] `false` because this is not an `Ok`.
+    def ok?()
+      false
+    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
@@ -166,6 +188,16 @@ module MonadOxide
       @data
     end
 
+    ##
+    # Safely unwrap the `Result`.  In the case of `Err`, this returns the
+    # wrapped value.
+    #
+    # @param _f A dummy function.  Not used.
+    # @return [T] The wrapped value.
+    def unwrap_err_or_else(f=nil, &_block)
+      @data
+    end
+
     ##
     # Safely unwrap the `Result`. In the case of `Err`, this returns the
     # provided default value.
@@ -176,5 +208,18 @@ module MonadOxide
       x
     end
 
+    ##
+    # Safely unwrap the `Result`. In the case of `Err`, this uses the provided
+    # function to produce a value.
+    #
+    # @param f [Proc<B>] The function to call. Could be a block
+    #          instead.  Takes nothing and returns a [B=Object].
+    # @yield Will yield a block that takes nothing and returns a [B=Object].
+    #        Same as `f' parameter.
+    # @return [B] The value returned from `f`.
+    def unwrap_or_else(f=nil, &block)
+      (f || block).call()
+    end
+
   end
 end

data/lib/ok.rb

@@ -40,6 +40,17 @@ module MonadOxide
       end
     end
 
+    ##
+    # Identifies that this is not an `Err`.
+    # For counterparts:
+    # @see MonadOxide::Ok#ok?
+    # @see MonadOxide::Err#ok?
+    # @see MonadOxide::Err#err?
+    # @return [Boolean] `false` because this is not an `Err`.
+    def err?()
+      false
+    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
@@ -96,6 +107,17 @@ module MonadOxide
       self
     end
 
+    ##
+    # Identifies that this is an `Ok`.
+    # For counterparts:
+    # @see MonadOxide::Ok#err?
+    # @see MonadOxide::Err#ok?
+    # @see MonadOxide::Err#err?
+    # @return [Boolean] `true` because this is an `Ok`.
+    def ok?()
+      true
+    end
+
     ##
     # The Err equivalent to Ok#and_then. This is a no-op for Ok. @see
     # Err#or_else.
@@ -124,13 +146,37 @@ module MonadOxide
       )
     end
 
+    ##
+    # Safely unwrap the `Result`.  In the case of `Ok`, this uses the provided
+    # function to produce a value.
+    #
+    # @param f [Proc<B>] The function to call. Could be a block
+    #          instead.  Takes nothing and returns a [B=Object].
+    # @yield Will yield a block that takes nothing and returns a [B=Object].
+    #        Same as `f' parameter.
+    # @return [B] The value returned from `f`.
+    def unwrap_err_or_else(f=nil, &block)
+      (f || block).call()
+    end
+
     ##
     # Safely unwrap the `Result`. In the case of `Ok`, this returns the
     # data in the Ok.
     #
-    # @param [B] x The value that will be returned.
+    # @param [B] _x The value that will be returned.
     # @return [A] The data in the Ok.
-    def unwrap_or(_)
+    def unwrap_or(_x)
+      @data
+    end
+
+    ##
+    # Safely unwrap the `Result`.  In the case of `Ok`, this returns the
+    # wrapped value.
+    #
+    # @param f [Proc<B>] A dummy function.  Not used.
+    #          instead.  Takes nothing and returns a [B=Object].
+    # @return [B] The value returned from `f`.
+    def unwrap_or_else(_f=nil, &_block)
       @data
     end
 

data/lib/result.rb

@@ -57,17 +57,10 @@ module MonadOxide
     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
+    # Determine if this is a MonadOxide::Err.
+    # @return [Boolean] `true` if this is a MonadOxide::Err, `false` otherwise.
+    def err?()
+      false
     end
 
     ##
@@ -113,6 +106,20 @@ module MonadOxide
       Err.new(ResultMethodNotImplementedError.new())
     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
+
     ##
     # 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
@@ -179,6 +186,13 @@ module MonadOxide
       matcher[self.class].call(@data)
     end
 
+    ##
+    # Determine if this is a MonadOxide::Ok.
+    # @return [Boolean] `true` if this is a MonadOxide::Ok, `false` otherwise.
+    def ok?()
+      false
+    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
@@ -226,6 +240,21 @@ module MonadOxide
       Err.new(ResultMethodNotImplementedError.new())
     end
 
+    ##
+    # Safely unwrap the `Result` but with lazy evaluation.  In the case of
+    # `Err`, this returns the wrapped value.  For `Ok` the function provided is
+    # evaluated and its returned value is what is returned.
+    #
+    # @param f [Proc<B>] The function to call for `Ok`. Could be a block
+    #          instead.  Takes nothing and returns a [B=Object].
+    # @yield Will yield a block for `Ok` that takes nothing and returns a
+    #        [B=Object].  Same as `f' parameter.
+    # @return [T|B] The wrapped value for `Err` and the returned from `f` for
+    #               `Ok`.
+    def unwrap_err_or_else(_f)
+      raise ResultMethodNotImplementedError.new()
+    end
+
     ##
     # Attempt to safely access the `Result` data. This always returns a value
     # instead of raising an Exception. In the case of `Ok`, the data is
@@ -236,5 +265,35 @@ module MonadOxide
       Err.new(ResultMethodNotImplementedError.new())
     end
 
+    ##
+    # Safely unwrap the `Result` but with lazy evaluation.  In the case of
+    # `Ok`, this returns the wrapped value.  For `Err` the function provided is
+    # evaluated and its returned value is what is returned.
+    #
+    # @param f [Proc<B>] The function to call for `Err`. Could be a block
+    #          instead.  Takes nothing and returns a [B=Object].
+    # @yield Will yield a block for `Err` that takes nothing and returns a
+    #        [B=Object].  Same as `f' parameter.
+    # @return [T|B] The wrapped value for `Ok` and the returned from `f` for
+    #               `Err`.
+    def unwrap_or_else(_f)
+      raise ResultMethodNotImplementedError.new()
+    end
+
+    ##
+    # Safely unwrap the `Result` but with lazy evaluation.  In the case of `Ok`,
+    # this returns the wrapped value.  For `Err` the function provided is
+    # evaluated and its returned value is what is returned.
+    #
+    # @param f [Proc<B>] The function to call for `Err`. Could be a block
+    #          instead.  Takes nothing and returns a [B=Object].
+    # @yield Will yield a block for `Err` that takes nothing and returns a
+    #        [B=Object].  Same as `f' parameter.
+    # @return [T|B] The wrapped value for `Ok` and the returned from `f` for
+    #               `Err`.
+    def unwrap_or_else(_f)
+      raise ResultMethodNotImplementedError.new()
+    end
+
   end
 end

data/lib/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.8.0'
+  VERSION='0.10.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monad-oxide
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Logan Barnett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-17 00:00:00.000000000 Z
+date: 2024-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: org-ruby