diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index f348764..ba7e8e6 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,12 +4,6 @@ updates:
   directory: "/"
   schedule:
     interval: daily
-  open-pull-requests-limit: 10
-  ignore:
-  - dependency-name: com.github.spotbugs:spotbugs-annotations
-    versions:
-    - 4.2.0
-    - 4.2.1
 - package-ecosystem: "github-actions"
   directory: "/"
   schedule:
diff --git a/.github/workflows/build-maven.yml b/.github/workflows/build-maven.yml
index f4c6b40..76fae11 100644
--- a/.github/workflows/build-maven.yml
+++ b/.github/workflows/build-maven.yml
@@ -11,9 +11,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        java: [ 8, 11, 16 ]
+        java: [ 11, 16 ]
     steps:
-      - uses: kamiazya/setup-graphviz@v1
       - uses: actions/checkout@v2
       - name: setup-jdk-${{ matrix.java }}
         uses: actions/setup-java@v2.1.0
diff --git a/.github/workflows/deploy-sonatype.yml b/.github/workflows/deploy-sonatype.yml
index b0d58af..1f68fe6 100644
--- a/.github/workflows/deploy-sonatype.yml
+++ b/.github/workflows/deploy-sonatype.yml
@@ -10,13 +10,12 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: kamiazya/setup-graphviz@v1
       - uses: actions/checkout@v2
       - name: Set up JDK
         uses: actions/setup-java@v2.1.0
         with:
           distribution: 'adopt'
-          java-version: 8
+          java-version: 11
       - name: Build with Maven
         run: mvn -B install
       - name: Nexus Repo Publish
diff --git a/README.md b/README.md
index 2f77f06..fc539ca 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ https://search.maven.org/artifact/net.kemitix/mon)
 - [Wrapper](#Wrapper) - light-weight type-alias-like
 - [TypeAlias](#TypeAlias) - type-alias-like monadic wrapper
 - [Maybe](#Maybe) - Maybe, Just or Nothing
-- [Result](#Result) - Result, Success or Err
+- [Result](https://kemitix.github.io/mon/net/kemitix/mon/result/package-summary.html) - Result, Success or Err
 - [Tree](#Tree) - generic trees
 - [Lazy](#Lazy) - lazy evaluation
 - [Either](#Either) - Either, Left or Right
@@ -402,292 +402,7 @@ Optional<Integer> optional = Maybe.maybe(getValue())
                                   .toOptional();
 ```
 ---
-## Result
 
-Allows handling error conditions without the need to `catch` exceptions.
-
-When a `Result` is returned from a method, it will contain one of two values.
-Either the actual result, or an error in the form of an `Exception`. The
-exception is returned within the `Result` and is not thrown.
-
-`Result` is a Monad.
-
-### Example
-
-``` java
-import net.kemitix.mon.result.Result;
-
-import java.io.IOException;
-
-class ResultExample implements Runnable {
-
-    public static void main(final String[] args) {
-        new ResultExample().run();
-    }
-
-    @Override
-    public void run() {
-        Result.of(() -> callRiskyMethod())
-              .flatMap(state -> doSomething(state))
-              .match(
-                  success -> System.out.println(success),
-                  error -> error.printStackTrace()
-              );
-    }
-
-    private String callRiskyMethod() throws IOException {
-        return "I'm fine";
-    }
-
-    private Result<String> doSomething(final String state) {
-        return Result.of(() -> state + ", it's all good.");
-    }
-
-}
-```
-
-In the above example the string `"I'm fine"` is returned by
-`callRiskyMethod()` within a successful `Result`. The `.flatMap()` call,
-unwraps that `Result` and, as it is a success, passes the contents to
-`doSomething()`, which in turn returns a `Result` that the `.flatMap()` call
-returns. `match()` is called on the `Result` and, being a success, will call
-the success `Consumer`.
-
-Had `callRiskyMethod()` thrown an exception it would have been caught by the
-`Result.of()` method, which would then return an error `Result`. An error
-`Result` would skip the `flatMap` and continue at the `match()` where it
-would have called the error `Consumer`.
-
-### Static Constructors
-
-#### `static <T> Result<T> of(Callable<T> callable)`
-
-Create a `Result` for the output of the `Callable`.
-
-If the `Callable` throws an `Exception`, then the `Result` will be an error and
-will contain that exception.
-
-This will be the main starting point for most `Result`s where the callable
-could throw an `Exception`.
-
-``` java
-Result<Integer> okay = Result.of(() -> 1);
-Result<Integer> error = Result.of(() -> {throw new RuntimeException();});
-```
----
-#### `static <T> Result<T> ok(T value)`
-
-Create a `Result` for a success.
-
-Use this where you have a value that you want to place into the `Result` context.
-
-``` java
-Result<Integer> okay = Result.ok(1);
-```
----
-#### `static <T> Result<T> error(Throwable error)`
-
-Create a `Result` for an error.
-
-``` java
-Result<Integer> error = Result.error(new RuntimeException());
-```
----
-### Static Methods
-
-These static methods provide integration with the `Maybe` class.
-
-#### `static <T> Maybe<T> toMaybe(Result<T> result)`
-
-Creates a `Maybe` from the `Result`, where the `Result` is a success, then
-the `Maybe` will be a `Just` contain the value of the `Result`. However, if the 
-`Result` is an error, then the `Maybe` will be `Nothing`.
-
-``` java
-Result<Integer> result = Result.of(() -> getValue());
-Maybe<Integer> maybe   = Result.toMaybe(result);
-```
----
-#### `static <T> Result<T> fromMaybe(Maybe<T> maybe, Supplier<Throwable> error)`
-
-Creates a `Result` from the `Maybe`, where the `Result` will be an error
-if the `Maybe` is nothing. Where the `Maybe` is nothing, then the
-`Supplier<Throwable>` will provide the error for the `Result`.
-
-``` java
-Maybe<Integer> maybe = Maybe.maybe(getValue());
-Result<Integer> result = Result.fromMaybe(maybe, 
-        () -> new NoSuchFileException("filename"));
-```
----
-#### `static <T> Result<Maybe<T>> invert(Maybe<Result<T>> maybeResult)`
-
-Swaps the `Result` within a `Maybe`, so that `Result` contains a `Maybe`.
-
-``` java
-Maybe<Result<Integer>> maybe = Maybe.maybe(Result.of(() -> getValue()));
-Result<Maybe<Integer>> result = Result.invert(maybe);
-```
----
-#### `static <T,R> Result<Maybe<R>> flatMapMaybe(Result<Maybe<T>> maybeResult, Function<Maybe<T>,Result<Maybe<R>>> f)`
-
-Applies the function to the contents of a `Maybe` within the `Result`.
-
-``` java
-Result<Maybe<Integer>> result = Result.of(() -> Maybe.maybe(getValue()));
-Result<Maybe<Integer>> maybeResult = Result.flatMapMaybe(result,
-        maybe -> Result.of(() -> maybe.map(v -> v * 2)));
-```
----
-### Instance Methods
-
-#### `<R> Result<R> map(Function<T,R> f)`
-
-If the `Result` is a success, then apply the function to the value within the 
-`Result`, returning the result within another `Result`. If the `Result` is an 
-error, then return the error.
-
-``` java
-Result<String> result = Result.of(() -> getValue())
-                              .map(v -> String.valueOf(v));
-```
----
-#### `<R> Result<R> flatMap(Function<T,Result<R>> f)`
-
-If the `Result` is a success, then return a new `Result` containing the result
-of applying the function to the contents of the `Result`. If the `Result` is an 
-error, then return the error.
-
-``` java
-Result<String> result = 
-        Result.of(() -> getValue())
-              .flatMap(v -> Result.of(() -> String.valueOf(v)));
-```
----
-#### `<R> Result<R> andThen(Function<T,Callable<R>> f)`
-
-Maps a successful `Result` to another `Result` using a `Callable` that is able
-to throw a checked exception.
-
-``` java
-Result<String> result =
-        Result.of(() -> getValue())
-              .andThen(v -> () -> {throw new IOException();});
-```
----
-#### `void match(Consumer<T> onSuccess, Consumer<Throwable> onError)`
-
-Matches the `Result`, either success or error, and supplies the appropriate
-`Consumer` with the value or error.
-
-``` java
-Result.of(() -> getValue())
-      .match(
-          success -> System.out.println(success),
-          error -> System.err.println(error.getMessage())
-      );
-```
----
-#### `Result<T> recover(Function<Throwable,Result<T>> f)`
-
-Provide a way to attempt to recover from an error state.
-
-``` java
-Result<Integer> result = Result.of(() -> getValue())
-                               .recover(e -> Result.of(() -> getSafeValue(e)));
-```
----
-#### `Result<T> peek(Consumer<T> consumer)`
-
-Provide the value within the Result, if it is a success, to the `Consumer`,
-and returns this Result.
-
-``` java
-Result<Integer> result = Result.of(() -> getValue())
-                               .peek(v -> System.out.println(v));
-```
----
-#### `Result<T> thenWith(Function<T,WithResultContinuation<T>> f)`
-
-Perform the continuation with the current `Result` value then return the
-current `Result`, assuming there was no error in the continuation.
-
-``` java
-Result<Integer> result =
-        Result.of(() -> getValue())
-              .thenWith(v -> () -> System.out.println(v))
-              .thenWith(v -> () -> {throw new IOException();});
-```
----
-#### `Result<Maybe<T>> maybe(Predicate<T> predicate)`
-
-Wraps the value within the `Result` in a `Maybe`, either a `Just` if the
-predicate is true, or `Nothing`.
-
-``` java
-Result<Maybe<Integer>> result = Result.of(() -> getValue())
-                                      .maybe(v -> v % 2 == 0);
-```
----
-#### `T orElseThrow()`
-
-Extracts the successful value from the `Result`, or throws the error
-within a `CheckedErrorResultException`.
-
-``` java
-Integer result = Result.of(() -> getValue())
-                       .orElseThrow();
-```
----
-#### `<E extends Exception> T orElseThrow(Class<E> type) throws E`
-
-Extracts the successful value from the `Result`, or throws the error when it
-is of the given type. Any other errors will be thrown inside an
-`UnexpectedErrorResultException`.
-
-``` java
-Integer result = Result.of(() -> getValue())
-                       .orElseThrow(IOException.class);
-```
----
-#### `T orElseThrowUnchecked()`
-
-Extracts the successful value from the `Result`, or throws the error within
-an `ErrorResultException`.
-
-``` java
-Integer result = Result.of(() -> getValue())
-                       .orElseThrowUnchecked();
-```
----
-#### `void onError(Consumer<Throwable> errorConsumer)`
-
-A handler for error states. If the `Result` is an error, then supply the error
-to the `Consumer`. Does nothing if the `Result` is a success.
-
-``` java
-Result.of(() -> getValue())
-      .onError(e -> handleError(e));
-```
----
-#### `boolean isOkay()`
-
-Checks if the `Result` is a success.
-
-``` java
-boolean isOkay = Result.of(() -> getValue())
-                       .isOkay();
-```
----
-#### `boolean isError()`
-
-Checks if the `Result` is an error.
-
-``` java
-boolean isError = Result.of(() -> getValue())
-                        .isError();
-```
----
 ## Tree
 
 A Generalised tree, where each node may or may not have an item, and may have
diff --git a/pom.xml b/pom.xml
index 7c4365e..44a377d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -33,7 +33,6 @@
     <inceptionYear>2017</inceptionYear>
 
     <properties>
-        <java.version>1.8</java.version>
         <junit.version>5.7.2</junit.version>
         <mockito.version>3.11.2</mockito.version>
         <assertj.version>3.20.2</assertj.version>
@@ -45,6 +44,7 @@
         <pitest-maven-plugin.version>1.6.8</pitest-maven-plugin.version>
         <pitest-junit5-plugin.version>0.14</pitest-junit5-plugin.version>
         <spotbugs.version>4.2.3</spotbugs.version>
+        <apiguardian-api.version>1.1.1</apiguardian-api.version>
     </properties>
 
     <dependencies>
@@ -55,6 +55,12 @@
             <scope>provided</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.apiguardian</groupId>
+            <artifactId>apiguardian-api</artifactId>
+            <version>${apiguardian-api.version}</version>
+        </dependency>
+
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
diff --git a/src/main/java/net/kemitix/mon/ThrowableFunctor.java b/src/main/java/net/kemitix/mon/ThrowableFunctor.java
new file mode 100644
index 0000000..273d6ba
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/ThrowableFunctor.java
@@ -0,0 +1,36 @@
+package net.kemitix.mon;
+
+import net.kemitix.mon.result.ThrowableFunction;
+
+/**
+ * The ThrowableFunctor is used for types that can be mapped over.
+ *
+ * <p>A ThrowableFunctor is identical to a normal Functor except that the
+ * map method may throw an exception.</p>
+ *
+ * <p>Implementations of ThrowableFunctor should satisfy the following laws:</p>
+ *
+ * <ul>
+ *     <li>map id  ==  id</li>
+ *     <li>map (f . g)  ==  map f . map g</li>
+ * </ul>
+ *
+ * @param <T> the type of the Functor
+ * @param <F> the type of the mapped Functor
+ *
+ * @author Paul Campbell (pcampbell@kemitix.net)
+ */
+public interface ThrowableFunctor<T, F extends ThrowableFunctor<?, ?>> {
+
+    /**
+     * Applies the function to the value within the ThrowableFunctor, returning
+     * the result within another ThrowableFunctor.
+     *
+     * @param f   the function to apply
+     * @param <R> the type of the content of the mapped functor
+     *
+     * @return a ThrowableFunctor containing the result of the function
+     * {@code f} applied to the value
+     */
+    <R> F map(ThrowableFunction<T, R, ?> f);
+}
diff --git a/src/main/java/net/kemitix/mon/TypeReference.java b/src/main/java/net/kemitix/mon/TypeReference.java
new file mode 100644
index 0000000..0d78a4f
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/TypeReference.java
@@ -0,0 +1,31 @@
+package net.kemitix.mon;
+
+/**
+ * Helper class to capture a reference to a type.
+ *
+ * <p>Usually to be used when passing a type as a parameter to method.</p>
+ *
+ * <pre><code>
+ * TypeReference&lt;Integer&gt; ref1 = TypeReference.create();
+ * var ref2 = TypeReference.&lt;Integer&gt;create();
+ * </code></pre>
+ *
+ * @param <T> the type being references
+ */
+@SuppressWarnings("PMD.ClassNamingConventions")
+final public class TypeReference<T> {
+
+    private TypeReference() {
+    }
+
+    /**
+     * Creates a new instance of a TypeReference.
+     *
+     * @param <R> the type being references.
+     * @return the TypeReference
+     */
+    public static <R> TypeReference<R> create() {
+        return new TypeReference<>();
+    }
+
+}
diff --git a/src/main/java/net/kemitix/mon/maybe/Maybe.java b/src/main/java/net/kemitix/mon/maybe/Maybe.java
index 03e8ff4..84c5469 100644
--- a/src/main/java/net/kemitix/mon/maybe/Maybe.java
+++ b/src/main/java/net/kemitix/mon/maybe/Maybe.java
@@ -94,6 +94,18 @@ public interface Maybe<T> extends Functor<T, Maybe<?>> {
                 .orElseGet(Maybe::nothing);
     }
 
+    /**
+     * Creates a Maybe from an Optional.
+     *
+     * @param optional the Optional
+     * @param <T> the type of the value
+     * @return a Just if the Optional contains a value, otherwise a Nothing
+     */
+    static <T> Maybe<T> fromOptional(Optional<T> optional) {
+        return optional.map(Maybe::maybe)
+                .orElseGet(Maybe::nothing);
+    }
+
     /**
      * Checks if the Maybe is a Just.
      *
diff --git a/src/main/java/net/kemitix/mon/result/BaseResult.java b/src/main/java/net/kemitix/mon/result/BaseResult.java
new file mode 100644
index 0000000..f83703d
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/result/BaseResult.java
@@ -0,0 +1,61 @@
+package net.kemitix.mon.result;
+
+import org.apiguardian.api.API;
+
+import java.util.function.Consumer;
+
+import static org.apiguardian.api.API.Status.STABLE;
+
+/**
+ * Base interface for {@link Result} and {@link ResultVoid}.
+ */
+public interface BaseResult {
+
+    /**
+     * Checks if the Result is an error.
+     *
+     * <pre><code>
+     * boolean isError = Result.of(() -&gt; getValue())
+     *                         .isError();
+     * </code></pre>
+     *
+     * @return true if the Result is an error.
+     */
+    @API(status = STABLE)
+    boolean isError();
+
+    /**
+     * Checks if the Result is a success.
+     *
+     * <pre><code>
+     * boolean isOkay = Result.of(() -> getValue())
+     *                        .isOkay();
+     * </code></pre>
+     *
+     * @return true if the Result is a success.
+     */
+    @API(status = STABLE)
+    boolean isOkay();
+
+    /**
+     * A handler for error states.
+     *
+     * <p>If the {@code Result} is an error, then supply the error
+     * to the {@code Consumer}. Does nothing if the {@code Result} is a
+     * success.</p>
+     *
+     * <p>When this is an error then tne Consumer will be supplied with the
+     * error. When this is a success, then nothing happens.</p>
+     *
+     * <pre><code>
+     * void handleError(Throwable e) {...}
+     * Result.of(() -> doSomething())
+     *       .onError(e -> handleError(e));
+     * </code></pre>
+     *
+     * @param errorConsumer the consumer to handle the error
+     */
+    @API(status = STABLE)
+    void onError(Consumer<Throwable> errorConsumer);
+
+}
diff --git a/src/main/java/net/kemitix/mon/result/Err.java b/src/main/java/net/kemitix/mon/result/Err.java
index da57110..6082cb8 100644
--- a/src/main/java/net/kemitix/mon/result/Err.java
+++ b/src/main/java/net/kemitix/mon/result/Err.java
@@ -22,14 +22,12 @@
 package net.kemitix.mon.result;
 
 import lombok.RequiredArgsConstructor;
-import net.kemitix.mon.maybe.Maybe;
 
 import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.Predicate;
 
 /**
  * An Error Result.
@@ -37,7 +35,8 @@ import java.util.function.Predicate;
  * @param <T> the type of the value in the Result if it has been a success
  */
 @RequiredArgsConstructor
-@SuppressWarnings({"methodcount", "PMD.CyclomaticComplexity"})
+@SuppressWarnings({"methodcount", "PMD.TooManyMethods", "PMD.ExcessivePublicCount",
+        "PMD.CyclomaticComplexity"})
 class Err<T> implements Result<T> {
 
     private final Throwable error;
@@ -54,12 +53,17 @@ class Err<T> implements Result<T> {
 
     @Override
     public <R> Result<R> flatMap(final Function<T, Result<R>> f) {
-        return err(error);
+        return new Err<>(error);
     }
 
     @Override
-    public <R> Result<R> map(final Function<T, R> f) {
-        return err(error);
+    public ResultVoid flatMapV(final Function<T, ResultVoid> f) {
+        return new ErrVoid(error);
+    }
+
+    @Override
+    public <R> Result<R> map(final ThrowableFunction<T, R, ?> f) {
+        return new Err<>(error);
     }
 
     @Override
@@ -67,18 +71,13 @@ class Err<T> implements Result<T> {
         onError.accept(error);
     }
 
-    @Override
-    public Result<Maybe<T>> maybe(final Predicate<T> predicate) {
-        return err(error);
-    }
-
     @Override
     public T orElseThrow() throws CheckedErrorResultException {
         throw CheckedErrorResultException.with(error);
     }
 
     @Override
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"unchecked", "PMD.AvoidDuplicateLiterals"})
     public <E extends Exception> T orElseThrow(final Class<E> type) throws E {
         if (type.isInstance(error)) {
             throw (E) error;
@@ -101,14 +100,31 @@ class Err<T> implements Result<T> {
         return f.apply(error);
     }
 
+    @Override
+    public void onSuccess(final Consumer<T> successConsumer) {
+        // do nothing
+    }
+
     @Override
     public void onError(final Consumer<Throwable> errorConsumer) {
         errorConsumer.accept(error);
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    public <E extends Throwable> Result<T> onError(
+            final Class<E> errorClass,
+            final Consumer<E> consumer
+    ) {
+        if (error.getClass().isAssignableFrom(errorClass)) {
+            consumer.accept((E) error);
+        }
+        return this;
+    }
+
     @Override
     public <R> Result<R> andThen(final Function<T, Callable<R>> f) {
-        return err(error);
+        return (Result<R>) this;
     }
 
     @Override
@@ -116,6 +132,11 @@ class Err<T> implements Result<T> {
         return this;
     }
 
+    @Override
+    public ResultVoid thenWithV(final Function<T, WithResultContinuation<T>> f) {
+        return toVoid();
+    }
+
     @Override
     public Result<T> reduce(final Result<T> identify, final BinaryOperator<T> operator) {
         return this;
@@ -123,7 +144,8 @@ class Err<T> implements Result<T> {
 
     @Override
     public boolean equals(final Object other) {
-        return other instanceof Err && Objects.equals(error, ((Err) other).error);
+        return other instanceof Err
+                && Objects.equals(error, ((Err) other).error);
     }
 
     @Override
@@ -135,4 +157,9 @@ class Err<T> implements Result<T> {
     public String toString() {
         return String.format("Result.Error{error=%s}", error);
     }
+
+    @Override
+    public ResultVoid toVoid() {
+        return new ErrVoid(error);
+    }
 }
diff --git a/src/main/java/net/kemitix/mon/result/ErrVoid.java b/src/main/java/net/kemitix/mon/result/ErrVoid.java
new file mode 100644
index 0000000..55c2b5f
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/result/ErrVoid.java
@@ -0,0 +1,79 @@
+package net.kemitix.mon.result;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class ErrVoid implements ResultVoid {
+
+    private final Throwable error;
+
+    ErrVoid(final Throwable error) {
+        this.error = error;
+    }
+
+    @Override
+    public boolean isError() {
+        return true;
+    }
+
+    @Override
+    public boolean isOkay() {
+        return false;
+    }
+
+    @Override
+    public void match(
+            final Runnable onSuccess,
+            final Consumer<Throwable> onError
+    ) {
+        onError.accept(error);
+    }
+
+    @Override
+    public ResultVoid recover(final Function<Throwable, ResultVoid> f) {
+        return f.apply(error);
+    }
+
+    @Override
+    public void onSuccess(final Runnable runnable) {
+        // do nothing
+    }
+
+    @Override
+    public void onError(final Consumer<Throwable> errorConsumer) {
+        errorConsumer.accept(error);
+    }
+
+    @Override
+    public <E extends Throwable> ResultVoid onError(
+            final Class<E> errorClass,
+            final Consumer<E> consumer
+    ) {
+        if (error.getClass().isAssignableFrom(errorClass)) {
+            consumer.accept((E) error);
+        }
+        return this;
+    }
+
+    @Override
+    public ResultVoid andThen(final VoidCallable f) {
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Result.ErrVoid{error=%s}", error);
+    }
+
+    @Override
+    public boolean equals(final Object other) {
+        return other instanceof ErrVoid && Objects.equals(error, ((ErrVoid) other).error);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(error);
+    }
+
+}
diff --git a/src/main/java/net/kemitix/mon/result/Result.java b/src/main/java/net/kemitix/mon/result/Result.java
index 038974e..d569d3e 100644
--- a/src/main/java/net/kemitix/mon/result/Result.java
+++ b/src/main/java/net/kemitix/mon/result/Result.java
@@ -21,178 +21,416 @@
 
 package net.kemitix.mon.result;
 
-import net.kemitix.mon.Functor;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import net.kemitix.mon.ThrowableFunctor;
+import net.kemitix.mon.TypeReference;
+import net.kemitix.mon.experimental.either.Either;
 import net.kemitix.mon.maybe.Maybe;
+import org.apiguardian.api.API;
 
 import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.*;
+import java.util.stream.Stream;
+
+import static org.apiguardian.api.API.Status.*;
 
 /**
- * An Either type for holding a result or an error (Throwable).
+ * A type for holding a <strong>result</strong> or an <strong>error</strong>.
+ *
+ * <h2>Static Constructors:</h2>
+ * <ul>
+ *     <li>{@link #ok()}</li>
+ *     <li>{@link #ok(Object)}</li>
+ *     <li>{@link #of(Callable)}</li>
+ *     <li>{@link #ofVoid(VoidCallable)}</li>
+ *     <li>{@link #error(Throwable)}</li>
+ *     <li>{@link #error(TypeReference, Throwable)}</li>
+ *     <li>{@link #from(Either)}</li>
+ *     <li>{@link #from(Maybe, Supplier)}</li>
+ * </ul>
  *
  * @param <T> the type of the result when a success
  * @author Paul Campbell (pcampbell@kemitix.net)
  */
-@SuppressWarnings({"methodcount", "PMD.TooManyMethods"})
-public interface Result<T> extends Functor<T, Result<?>> {
+@SuppressWarnings({"methodcount", "PMD.TooManyMethods", "PMD.ExcessivePublicCount", "PMD.ExcessiveClassLength",
+        "PMD.AvoidCatchingThrowable"})
+public interface Result<T> extends BaseResult, ThrowableFunctor<T, ThrowableFunctor<?, ?>> {
+
+    // BEGIN Static Constructors
 
     /**
-     * Creates a Result from the Maybe, where the Result will be an error if the Maybe is Nothing.
+     * Creates a success Result with no value.
      *
-     * @param maybe the Maybe the might contain the value of the Result
-     * @param error the error that will be the Result if maybe is Nothing
-     * @param <T>   the type of the Maybe and the Result
-     * @return a Result containing the value of the Maybe when it is a Just, or the error when it is Nothing
+     * <pre><code>
+     * ResultVoid okay = Result.ok();
+     * </code></pre>
+     * @return a successful Result
      */
-    static <T> Result<T> fromMaybe(final Maybe<T> maybe, final Supplier<Throwable> error) {
-        return maybe.map(Result::ok)
-                .orElseGet(() -> Result.error(error.get()));
+    @API(status = STABLE)
+    static ResultVoid ok() {
+        return SuccessVoid.getInstance();
     }
 
     /**
-     * Create a Result for an error.
+     * Create a success Result with a value.
      *
-     * @param error the error (Throwable)
-     * @param <T>   the type had the result been a success
-     * @return an error Result
+     * <pre><code>
+     * Result&lt;Integer&gt; okay = Result.ok(1);
+     * </code></pre>
+     *
+     * @param value the value
+     * @param <R>   the type of the value
+     * @return a successful Result
      */
-    default <T> Result<T> err(final Throwable error) {
-        return new Err<>(error);
+    @API(status = STABLE)
+    static <R> Result<R> ok(final R value) {
+        return new Success<>(value);
     }
 
     /**
-     * Create a Result for an error.
+     * Create a {@link Result} for the output of the {@link Callable}.
      *
-     * @param error the error (Throwable)
-     * @param <T>   the type had the result been a success
-     * @return an error Result
-     */
-    static <T> Result<T> error(final Throwable error) {
-        return new Err<>(error);
-    }
-
-    /**
-     * Create a Result for a output of the Callable.
+     * <p>If the {@code Callable} succeeds then the {@code Result} will be a
+     * {@link Success} and will contain the value.
+     * If it throws an {@code Exception}, then the {@code Result} will be an
+     * {@link Err} and will contain that exception.</p>
+     *
+     * <pre><code>
+     * Result&lt;Integer$gt; okay = Result.of(() -&gt; 1);
+     * Result&lt;Integer&gt; error = Result.of(() -&gt; {
+     *     throw new RuntimeException();
+     * });
+     * </code></pre>
      *
      * @param callable the callable to produce the result
      * @param <T>      the type of the value
      * @return a Result
      */
-    @SuppressWarnings({"illegalcatch", "PMD.AvoidCatchingThrowable", "PMD.AvoidDuplicateLiterals"})
-    default <T> Result<T> result(final Callable<T> callable) {
-        try {
-            return Result.ok(callable.call());
-        } catch (final Throwable e) {
-            return Result.error(e);
-        }
-    }
-
-    /**
-     * Create a Result for a output of the Callable.
-     *
-     * @param callable the callable to produce the result
-     * @param <T>      the type of the value
-     * @return a Result
-     */
-    @SuppressWarnings({"illegalcatch", "PMD.AvoidCatchingThrowable"})
+    @API(status = STABLE)
     static <T> Result<T> of(final Callable<T> callable) {
         try {
             return Result.ok(callable.call());
+        } catch (final Throwable e) {
+            return new Err<>(e);
+        }
+    }
+
+    /**
+     * Create a {@code ResultVoid} after calling a {@link VoidCallable}
+     * that produces no output.
+     *
+     * <p>If the {@code callable} completes successfully then a
+     * {@link SuccessVoid} will be returned. if the {@code callable} throws an
+     * exception, then a {@link ErrVoid} containing the exception will be
+     * returned.</p>
+     *
+     * <pre><code>
+     * ResultVoid okay = Result.ofVoid(() -&gt; System.out.println("Hello, World!"));
+     * ResultVoid error = Result.ofVoid(() -&gt; {
+     *     throw new Exception();
+     * });
+     * </code></pre>
+     *
+     * @param callable the callable to call
+     * @return a Result with no value
+     */
+    @API(status = STABLE)
+    static ResultVoid ofVoid(final VoidCallable callable) {
+        try {
+            callable.call();
+            return Result.ok();
         } catch (final Throwable e) {
             return Result.error(e);
         }
     }
 
     /**
-     * Create a Result for a success.
+     * Create a Result for an error.
      *
-     * @param value the value
-     * @param <T>   the type of the value
-     * @return a successful Result
+     * <pre><code>
+     * ResultVoid error = Result.error(new RuntimeException());
+     * </code></pre>
+     *
+     * @param error the error (Throwable)
+     * @return an error Result
      */
-    default <T> Result<T> success(final T value) {
-        return new Success<>(value);
+    @API(status = STABLE)
+    static ResultVoid error(final Throwable error) {
+        return new ErrVoid(error);
     }
 
     /**
-     * Create a Result for a success.
+     * Create a Result for an error.
      *
-     * @param value the value
-     * @param <T>   the type of the value
-     * @return a successful Result
+     * <pre><code>
+     * Result&lt;Integer&gt; error = Result.error(TypeReference.create(), new RuntimeException());
+     * </code></pre>
+     *
+     * @param type the type of the missing) value
+     * @param error the error (Throwable)
+     * @param <R> The type of the missing value
+     * @return an error Result
      */
-    static <T> Result<T> ok(final T value) {
-        return new Success<>(value);
+    @API(status = STABLE)
+    @SuppressFBWarnings(value = "UP_UNUSED_PARAMETER",
+            justification = "Use the type parameter to fingerprint the return type")
+    static <R> Result<R> error(final TypeReference<R> type, final Throwable error) {
+        return new Err<>(error);
     }
 
     /**
-     * Creates a {@link Maybe} from the Result, where the Result is a success, then the Maybe will contain the value.
+     * Creates a Result from the Either, where the Result will be an error if
+     * the Either is a Left, and a success if it is a Right.
      *
-     * <p>However, if the Result is an error then the Maybe will be nothing.</p>
+     * <pre><code>
+     * import net.kemitix.mon.experimental.either.Either;
      *
-     * @param result the Result the might contain the value of the Result
-     * @param <T>    the type of the Maybe and the Result
+     * Either&lt;Throwable, String&gt; eitherRight = Either.right("Hello, World!");
+     * Either&lt;Throwable, String&gt; eitherLeft = Either.left(new RuntimeException());
+     *
+     * Result&lt;String&gt; success = Result.from(eitherRight);
+     * Result&lt;String&gt; error = Result.from(eitherLeft);
+     * </code></pre>
+     *
+     * @param either the either that could contain an error in left or a value in right
+     * @param <T>    the type of the right value
+     * @return a Result containing the right value of the Either when it is a
+     * Right, or the left error when it is a Left.
+     */
+    @API(status = EXPERIMENTAL)
+    static <T> Result<T> from(Either<Throwable, T> either) {
+        return Result.from(
+                Maybe.fromOptional(either.getRight()),
+                () -> either.getLeft().get());
+    }
+
+    /**
+     * Creates a Result from the Maybe, where the Result will be an error if the Maybe is Nothing.
+     *
+     * <p>Where the {@code Maybe} is nothing, then the Supplier will provide the error for the Result.</p>
+     *
+     * <pre><code>
+     * Maybe&lt;Integer&gt; maybe = Maybe.maybe(1);
+     * Result&lt;Integer&gt; result = Result.from(maybe, () -&gt; new RuntimeException());&lt;/p&gt;
+     * </code></pre>
+     *
+     * @param maybe the Maybe the might contain the value of the Result
+     * @param error the error that will be the Result if maybe is Nothing
+     * @param <T>   the type of the value in the Maybe and the Result
      * @return a Result containing the value of the Maybe when it is a Just, or the error when it is Nothing
      */
-    static <T> Maybe<T> toMaybe(final Result<T> result) {
-        try {
-            return Maybe.just(result.orElseThrow());
-        } catch (final CheckedErrorResultException throwable) {
-            return Maybe.nothing();
-        }
+    @API(status = EXPERIMENTAL)
+    static <T> Result<T> from(final Maybe<T> maybe, final Supplier<Throwable> error) {
+        return maybe.map(Result::ok)
+                .orElseGet(() -> new Err<>(error.get()));
+    }
+
+    // END Static Constructors
+    // BEGIN Static methods
+
+    /**
+     * Applies a function to a stream of values, folding the results using the
+     * zero value and accumulator function.
+     *
+     * <p>Returns a success {@code Result} of the accumulated outputs if all
+     * values were transformed successfully by the function, or an error
+     * {@code Result} for the first error. If any value results in an error when applying the function, then
+     * processing stops and a Result containing that error is returned,</p>
+     *
+     * <pre><code>
+     * Function&lt;String, Integer&gt; f = s -&gt; {
+     *     if ("dd".equals(s)) {
+     *         throw new RuntimeException("Invalid input: " + s);
+     *     }
+     *     return s.length();
+     * };
+     *
+     * Stream&lt;String&gt; okayStream = Stream.of("aa", "bb");
+     * Result&lt;Integer&gt; resultOkay = Result.applyOver(okayStream, f, 0, Integer::sum);
+     * resultOkay.match(
+     *     success -&gt; System.out.println("Total length: " + success),
+     *     error -&gt; System.out.println("Error: " + error.getMessage())
+     * );
+     * // Total length: 4
+     *
+     * Stream&lt;String&gt; errorStream = Stream.of("cc", "dd");
+     * Result&lt;Integer&gt; resultError = Result.applyOver(errorStream, f, 0, Integer::sum);
+     * resultError.match(
+     *     success -&gt; System.out.println("Total length: " + success), // will not match
+     *     error -&gt; System.out.println("Error: " + error.getMessage())
+     * );
+     * // Error: Invalid input: dd
+     * </code></pre>
+     *
+     * @param stream      the values to apply the function to
+     * @param f           the function to apply to the values
+     * @param zero        the initial value to use with the accumulator
+     * @param accumulator the function to combine function outputs together
+     * @param <N>         the type of the stream values
+     * @param <R>         the type of the output value
+     * @return a Success Result of the accumulated function outputs if all
+     * values were transformed successfully by the function, or an Err Result
+     * for the first value that failed.
+     */
+    @API(status = STABLE)
+    static <N, R> Result<R> applyOver(
+            Stream<N> stream,
+            Function<N, R> f,
+            R zero,
+            BiFunction<R, R, R> accumulator
+    ) {
+        var acc = new AtomicReference<>(Result.ok(zero));
+        stream.map(t -> Result.of(() -> f.apply(t)))
+                .peek(r ->
+                        r.onSuccess(vNew ->
+                                acc.getAndUpdate(rResult ->
+                                        rResult.map(vOld ->
+                                                accumulator.apply(vNew, vOld)))))
+                .dropWhile(Result::isOkay)
+                .limit(1)
+                .forEach(acc::set);
+        return acc.get();
     }
 
     /**
-     * Extracts the successful value from the result, or throws the error within a {@link CheckedErrorResultException}.
+     * Applies a consumer to a stream of values.
      *
-     * @return the value if a success
-     * @throws CheckedErrorResultException if the result is an error
+     * <p>If any value results in an error when accepted by the consumer, then
+     * processing stops and a Result containing that error is returned,</p>
+     *
+     * <p>Returns a success Result (with no value) if all values were consumed
+     * successfully by the function, or an error Result for the first value that
+     * failed.</p>
+     *
+     * <pre><code>
+     * List&lt;String&gt; processed = new ArrayList&lt;&gt;();
+     * Consumer&lt;String&gt; consumer = s -&gt; {
+     *     if ("dd".equals(s)) {
+     *         throw new RuntimeException("Invalid input: " + s);
+     *     }
+     *     processed.add(s);
+     * };
+     *
+     * Stream&lt;String&gt; okayStream = Stream.of("aa", "bb");
+     * ResultVoid resultOkay = Result.applyOver(okayStream, consumer);
+     * resultOkay.match(
+     *         () -&gt; System.out.println("All processed okay."),
+     *         error -&gt; System.out.println("Error: " + error.getMessage())
+     * );
+     * System.out.println("Processed: " + processed);
+     * // All processed okay.
+     * // Processed: [aa, bb]
+     *
+     * processed.add("--");
+     * Stream&lt;String&gt; errorStream = Stream.of("cc", "dd", "ee");// fails at 'dd'
+     * ResultVoid resultError = Result.applyOver(errorStream, consumer);
+     * resultError.match(
+     *         () -&gt; System.out.println("All processed okay."),
+     *         error -&gt; System.out.println("Error: " + error.getMessage())
+     * );
+     * System.out.println("Processed: " + processed);
+     * // Error: Invalid input: dd
+     * // Processed: [aa, bb, --, cc]
+     * </code></pre>
+     *
+     * @param stream   the value to supply to the consumer
+     * @param consumer the consumer to receive the values
+     * @param <N>      the type of the stream values
+     * @return a Success Result (with no value) if all values were transformed
+     * successfully by the function, or an Err Result for the first value that
+     * failed.
      */
-    T orElseThrow() throws CheckedErrorResultException;
-
-    /**
-     * Extracts the successful value from the result, or throws the error Throwable.
-     *
-     * @param type the type of checked exception that may be thrown
-     * @param <E> the type of the checked exception to throw
-     *
-     * @return the value if a success
-     * @throws E if the result is an error
-     */
-    <E extends Exception> T orElseThrow(Class<E> type) throws E;
-
-    /**
-     * Extracts the successful value from the result, or throws the error in a {@link UnexpectedErrorResultException}.
-     *
-     * @return the value if a success
-     */
-    T orElseThrowUnchecked();
-
-    /**
-     * Swaps the inner Result of a Maybe, so that a Result is on the outside.
-     *
-     * @param maybeResult the Maybe the contains a Result
-     * @param <T>         the type of the value that may be in the Result
-     * @return a Result containing a Maybe, the value in the Maybe was the value in a successful Result within the
-     * original Maybe. If the original Maybe is Nothing, the Result will contain Nothing. If the original Result was an
-     * error, then the Result will also be an error.
-     */
-    static <T> Result<Maybe<T>> swap(final Maybe<Result<T>> maybeResult) {
-        return maybeResult.orElseGet(() -> Result.ok(null))
-                .flatMap(value -> Result.ok(Maybe.maybe(value)));
+    @API(status = STABLE)
+    static <N> ResultVoid applyOver(
+            Stream<N> stream,
+            Consumer<N> consumer
+    ) {
+        return applyOver(stream, n -> {
+            consumer.accept(n);
+            return null;
+        }, null, (unused1, unused2) -> null)
+                .toVoid();
     }
 
     /**
-     * Returns a new Result consisting of the result of applying the function to the contents of the Result.
+     * Applies a function to a stream of values, folding the results using the
+     * zero value and accumulator function.
      *
-     * @param f   the mapping function the produces a Result
-     * @param <R> the type of the value withing the Result of the mapping function
-     * @return a Result
+     * <p>If any value results in an error when applying the function, then
+     * processing stops and a {@code Result} containing that error is returned.</p>
+     *
+     * <p>Returns a success {@code Result} of the accumulated function outputs
+     * if all values were transformed successfully, or an error {@code Result}
+     * for the first value that failed.</p>
+     *
+     * <p>Similar to {@link #applyOver(Stream, Function, Object, BiFunction)},
+     * except that the result of the {@code f} function is a {@code Result}; and
+     * to a {@code flatMap} method in that the {@code Result} is not nested with
+     * in another {@code Result}.</p>
+     *
+     * <pre><code>
+     * Function&lt;String, Integer&gt; f = s -&gt; {
+     *     if ("dd".equals(s)) {
+     *         throw new RuntimeException("Invalid input: " + s);
+     *     }
+     *     return s.length();
+     * };
+     *
+     * Stream&lt;String&gt; okayStream = Stream.of("aa", "bb");
+     * Result&lt;Integer&gt; resultOkay = Result.applyOver(okayStream, f, 0, Integer::sum);
+     * resultOkay.match(
+     *     success -&gt; assertThat(success).isEqualTo(4),
+     *     error -&gt; fail("not an err")
+     * );
+     * // Total length: 4
+     *
+     * Stream&lt;String&gt; errorStream = Stream.of("cc", "dd");
+     * Result&lt;Integer&gt; resultError = Result.applyOver(errorStream, f, 0, Integer::sum);
+     * resultError.match(
+     *     success -&gt; fail("not a success"), // will not match
+     *     error -&gt; assertThat(error.getMessage()).isEqualTo("Invalid input: dd")
+     * );
+     * // Error: Invalid input: dd
+     * </code></pre>
+     *
+     * @param stream      the values to apply the function to
+     * @param f           the function to apply to the values
+     * @param zero        the initial value to use with the accumulator
+     * @param accumulator the function to combine function outputs together
+     * @param <T>         the type of the stream values
+     * @param <R>         the type of the output value
+     * @return a Success Result of the accumulated function outputs if all
+     * values were transformed successfully by the function, or an Err Result
+     * for the first value that failed.
      */
-    <R> Result<R> flatMap(Function<T, Result<R>> f);
+    @API(status = STABLE)
+    static <T, R> Result<R> flatApplyOver(
+            Stream<T> stream,
+            Function<T, Result<R>> f,
+            R zero,
+            BiFunction<R, R, R> accumulator
+    ) {
+        var acc = new AtomicReference<>(Result.ok(zero));
+        stream.map(f)
+                .peek(r -> r.onSuccess(vNew ->
+                        acc.getAndUpdate(rResult ->
+                                rResult.map(vOld ->
+                                        accumulator.apply(vNew, vOld)))))
+                .dropWhile(Result::isOkay)
+                .limit(1)
+                .forEach(acc::set);
+        return acc.get();
+    }
 
     /**
-     * Applies the function to the contents of a Maybe within the Result.
+     * Applies the function to the contents of a {@link Maybe} within the {@code Result}.
+     *
+     * <pre><code>
+     * Result&lt;Maybe&lt;Integer&gt;&gt; result = Result.of(() -&gt; Maybe.maybe(getValue()));
+     * Result&lt;Maybe&lt;Integer&gt;&gt; maybeResult = Result.flatMapMaybe(result,
+     *        maybe -&gt; Result.of(() -&gt; maybe.map(v -&gt; v * 2)));
+     * </code></pre>
      *
      * @param maybeResult the Result that may contain a value
      * @param f           the function to apply to the value
@@ -200,6 +438,7 @@ public interface Result<T> extends Functor<T, Result<?>> {
      * @param <R>         the type of the updated Result
      * @return a new Maybe within a Result
      */
+    @API(status = EXPERIMENTAL)
     static <T, R> Result<Maybe<R>> flatMapMaybe(
             final Result<Maybe<T>> maybeResult,
             final Function<Maybe<T>, Result<Maybe<R>>> f
@@ -208,63 +447,296 @@ public interface Result<T> extends Functor<T, Result<?>> {
     }
 
     /**
-     * Checks if the Result is an error.
+     * Swaps the inner {@code Result} of a {@link Maybe}, so that a {@code Result} contains a {@code Maybe}.
      *
-     * @return true if the Result is an error.
+     * @param maybeResult the Maybe the contains a Result
+     * @param <T>         the type of the value that may be in the Result
+     * @return a Result containing a Maybe, the value in the Maybe was the value in a successful Result within the
+     * original Maybe. If the original Maybe is Nothing, the Result will contain Nothing. If the original Result was an
+     * error, then the Result will also be an error.
+     * @deprecated
      */
-    boolean isError();
+    @API(status = DEPRECATED)
+    @Deprecated
+    static <T> Result<Maybe<T>> swap(final Maybe<Result<T>> maybeResult) {
+        return maybeResult.orElseGet(() -> Result.ok(null))
+                .flatMap(value -> Result.ok(Maybe.maybe(value)));
+    }
 
     /**
-     * Checks if the Result is a success.
+     * Creates a {@link Maybe} from the {@code Result}.
      *
-     * @return true if the Result is a success.
+     * <p>Where the {@code Result} is a {@link Success}, the {@code Maybe} will be a {@code Just} contain the value of
+     * the {@code Result}.</p>
+     *
+     * <p>However, if the {@code Result} is an {@link Err}, then the {@code Maybe} will be {@code Nothing}.</p>
+     *
+     * <pre><code>
+     * Result&lt;Integer&gt; result = Result.of(() -&gt; getValue());
+     * Maybe&lt;Integer&gt; maybe = Result.toMaybe(result);
+     * </code></pre>
+     *
+     * @param result the Result the might contain the value of the Result
+     * @param <T>    the type of the Maybe and the Result
+     * @return a Result containing the value of the Maybe when it is a Just, or the error when it is Nothing
      */
-    boolean isOkay();
+    @API(status = EXPERIMENTAL)
+    static <T> Maybe<T> toMaybe(final Result<T> result) {
+        try {
+            return Maybe.just(result.orElseThrow());
+        } catch (final CheckedErrorResultException throwable) {
+            return Maybe.nothing();
+        }
+    }
 
+    // END Static methods
+
+    /**
+     * Create a {@link Result} for the output of the {@link Callable}.
+     *
+     * <p>If the {@code Callable} succeeds then the {@code Result} will be a
+     * {@link Success} and will contain the value.
+     * If it throws an {@code Exception}, then the {@code Result} will be an
+     * {@link Err} and will contain that exception.</p>
+     *
+     * <pre><code>
+     * Result&lt;Integer&gt; start = Result.ok(1);
+     * Result&lt;Integer&gt; okay = start.result(() -&gt; 1);
+     * Result&lt;Integer&gt; error = start.result(() -&gt; {
+     *     throw new RuntimeException();
+     * });
+     * </code></pre>
+     *
+     * @param callable the callable to produce the result
+     * @param <R>      the type of the value
+     * @return a Result
+     */
+    @API(status = EXPERIMENTAL)
+    default <R> Result<R> result(final Callable<R> callable) {
+        return Result.of(callable);
+    }
+
+    /**
+     * Converts the {@code Result} into an {@link Either}.
+     * 
+     * <pre><code>
+     * Result&lt;String&gt; success = Result.ok("success");
+     * RuntimeException exception = new RuntimeException();
+     * Result&lt;String&gt; error = Result.error(String.class, exception);
+     *
+     * Either&lt;Throwable, String&gt; eitherRight = success.toEither();
+     * Either&lt;Throwable, String&gt; eitherLeft = error.toEither();
+     * </code></pre>
+     *
+     * @return A {@code Right} for a success or a {@code Left} for an error.
+     */
+    @API(status = EXPERIMENTAL)
+    default Either<Throwable, T> toEither() {
+        var either = new AtomicReference<Either<Throwable, T>>();
+        match(
+                success -> either.set(Either.right(success)),
+                error -> either.set(Either.left(error))
+        );
+        return either.get();
+    }
+
+    /**
+     * Extracts the successful value from the result, or throws a {@link CheckedErrorResultException} with the error
+     * as the cause.
+     *
+     * <pre><code>
+     * Integer result = Result.of(() -&gt; getValue())
+     *                        .orElseThrow();
+     * </code></pre>
+     *
+     * @return the value if a success
+     * @throws CheckedErrorResultException if the result is an error
+     */
+    @API(status = STABLE)
+    T orElseThrow() throws CheckedErrorResultException;
+
+    /**
+     * Return the successful value from the result, or throws the error if it is an instance of the type specified,
+     * otherwise it will throw an {@link UnexpectedErrorResultException} with the error as the cause.
+     *
+     * <pre><code>
+     * Integer result = Result.of(() -&gt; getValue())
+     *                        .orElseThrow(IOException.class);
+     * </code></pre>
+     *
+     * @param type the type of checked exception that may be thrown
+     * @param <E>  the type of the checked exception to throw
+     * @return the value if a success
+     * @throws E if the result is an error
+     */
+    @API(status = STABLE)
+    <E extends Exception> T orElseThrow(Class<E> type) throws E;
+
+    /**
+     * Returns the successful value from the result, or throws an {@link ErrorResultException}, an unchecked exception,
+     * with the error as the cause.
+     *
+     * <pre><code>
+     * Integer result = Result.of(() -&gt; getValue())
+     *                        .orElseThrowUnchecked();
+     * </code></pre>
+     *
+     * @return the value if a success
+     */
+    @API(status = STABLE)
+    T orElseThrowUnchecked();
+
+    /**
+     * Applies the function to the value within the {@code Result} and returns the result if this is a success,
+     * otherwise returns a new {@code Result} with the existing error.
+     *
+     * <pre><code>
+     * Result&lt;String&gt; result = Result.of(() -&gt; getValue())
+     *                               .flatMap(v -&gt; Result.of(() -&gt; String.valueOf(v)));
+     * </code></pre>
+     *
+     * @param f   the mapping function the produces a Result
+     * @param <R> the type of the value withing the Result of the mapping function
+     * @return a Result
+     */
+    @API(status = STABLE)
+    <R> Result<R> flatMap(Function<T, Result<R>> f);
+
+    /**
+     * Applies the function to the value within the {@code Result} and returns the void result if this is a success,
+     * otherwise returns a new {@code Result} with the existing error.
+     *
+     * <pre><code>
+     * ResultVoid result = Result.of(() -> getValue())
+     *                           .flatMapV(v -> Result.ok());
+     * </code></pre>
+     *
+     * @param f   the mapping function the produces a ResultVoid
+     * @return a ResultVoid
+     */
+    @API(status = STABLE)
+    ResultVoid flatMapV(Function<T, ResultVoid> f);
+
+    /**
+     * Applies the function to the value within the {@code Result}, returning
+     * the result within another {@code Result}.
+     *
+     * <p>If the initial {@code Result} is a success, then apply the function to
+     * the value within the {@code Result}, returning the result within another
+     * {@code Result}. If the initial {@code Result} is an error, then return
+     * another error without invoking the supplied function.</p>
+     *
+     * <p>If the supplied function throws an exception, then an error
+     * {@code Result} will be returned containing that exception.</p>
+     *
+     * <pre><code>
+     * Result&lt;String&gt; result = Result.of(() -&gt; getValue())
+     *                               .map(v -&gt; String.valueOf(v));
+     * </code></pre>
+     *
+     * @param f   the function to apply
+     * @param <R> the type of the value returned by the function to be applied
+     * @return A {@code Result} containing either the original error, the
+     * function output, or any exception thrown by the supplied function.
+     */
     @Override
-    <R> Result<R> map(Function<T, R> f);
+    @API(status = STABLE)
+    <R> Result<R> map(ThrowableFunction<T, R, ?> f);
 
     /**
-     * Matches the Result, either success or error, and supplies the appropriate Consumer with the value or error.
+     * Matches the Result, either success or error, and supplies the appropriate
+     * Consumer with the value or error.
+     *
+     * <pre><code>
+     * Result.of(()-> getValue())
+     *       .match(
+     *           success -> doSomething(success),
+     *           error -> handleError(error)
+     *       );
+     * </code></pre>
      *
      * @param onSuccess the Consumer to pass the value of a successful Result to
      * @param onError   the Consumer to pass the error from an error Result to
      */
+    @API(status = STABLE)
     void match(Consumer<T> onSuccess, Consumer<Throwable> onError);
 
-    /**
-     * Wraps the value within the Result in a Maybe, either a Just if the predicate is true, or Nothing.
-     *
-     * @param predicate the test to decide
-     * @return a Result containing a Maybe that may or may not contain a value
-     */
-    Result<Maybe<T>> maybe(Predicate<T> predicate);
-
     /**
      * Provide the value within the Result, if it is a success, to the Consumer, and returns this Result.
      *
+     * <pre><code>
+     * Result&lt;Integer&gt; result = Result.of(() -&gt; getValue())
+     *                                .peek(v -&gt; System.out.println(v));
+     * </code></pre>
+     *
      * @param consumer the Consumer to the value if a success
      * @return this Result
      */
+    @API(status = STABLE)
     Result<T> peek(Consumer<T> consumer);
 
     /**
-     * Provide a way to attempt to recover from an error state.
+     * Attempts to restore an error {@code Result} to a success.
+     *
+     * <p>When the Result is already a success, then the result is returned
+     * unmodified.</p>
+     *
+     * <pre><code>
+     * Result&lt;Integer&gt; result = Result.of(() -&gt; getValue())
+     *                                .recover(e -> Result.of(() -&gt; getSafeValue(e)));
+     * </code></pre>
      *
      * @param f the function to recover from the error
-     * @return a new Result, either a Success, or if recovery is not possible an other Err.
+     * @return if Result is an error, a new Result, either a Success, or if
+     * recovery is not possible another error. If the Result is already a
+     * success, then this returns itself.
      */
+    @API(status = STABLE)
     Result<T> recover(Function<Throwable, Result<T>> f);
 
     /**
-     * A handler for error states.
+     * A handler for success states.
      *
-     * <p>When this is an error then tne Consumer will be supplier with the error. When this is a success, then nothing
-     * happens.</p>
+     * <pre><code>
+     * void handleSuccess(Integer value) {...}
+     * Result.of(() -> getValue())
+     *       .onSuccess(v -> handleSuccess(v));
+     * </code></pre>
      *
-     * @param errorConsumer the consumer to handle the error
+     * <p>When this is a success then tne Consumer will be supplied with the
+     * success value. When this is an error, then nothing happens.</p>
+     *
+     * @param successConsumer the consumer to handle the success
      */
-    void onError(Consumer<Throwable> errorConsumer);
+    @API(status = STABLE)
+    void onSuccess(Consumer<T> successConsumer);
+
+    /**
+     * A handler for error state, when the error matches the errorClass.
+     *
+     * <p>If the `Result` is an error and that error is an instance of the
+     * errorClass, then supply the error to the `Consumer`. Does nothing if the
+     * error is not an instance of the errorClass, or is a success.</p>
+     *
+     * <p>Similar to the catch block in a try-catch.</p>
+     *
+     * <pre><code>
+     * void handleError(UnsupportedOperationException e) {...}
+     * Result.of(() -&gt; getValue())
+     *       .onError(UnsupportedOperationException.class,
+     *                e -&gt; handleError(e))
+     * </code></pre>
+     *
+     * @param errorClass the class of Throwable to match
+     * @param consumer the consumer to call if it matches
+     * @param <E> the Type of the Throwable to match
+     * @return the original unmodified Result
+     */
+    @API(status = STABLE)
+    <E extends Throwable> Result<T> onError(
+            Class<E> errorClass,
+            Consumer<E> consumer
+    );
 
     /**
      * Maps a Success Result to another Result using a Callable that is able to throw a checked exception.
@@ -272,10 +744,10 @@ public interface Result<T> extends Functor<T, Result<?>> {
      * <p>Combination of {@link #flatMap(Function)} and {@link #of(Callable)}.</p>
      *
      * <pre><code>
-     *     Integer doSomething() {...}
-     *     String doSomethingElse(final Integer value) {...}
-     *     Result&lt;String&gt; r = Result.of(() -&gt; doSomething())
-     *                              .andThen(value -&gt; () -&gt; doSomethingElse(value));
+     * Integer doSomething() {...}
+     * String doSomethingElse(final Integer value) {...}
+     * Result&lt;String&gt; r = Result.of(() -&gt; doSomething())
+     *                          .andThen(value -&gt; () -&gt; doSomethingElse(value));
      * </code></pre>
      *
      * <p>When the Result is an Err, then the original error is carried over and the Callable is never called.</p>
@@ -283,18 +755,47 @@ public interface Result<T> extends Functor<T, Result<?>> {
      * @param f   the function to map the Success value into the Callable
      * @param <R> the type of the final Result
      * @return a new Result
+     * @deprecated Use {@link #map(ThrowableFunction)}
      */
+    @API(status = DEPRECATED)
+    @Deprecated
     <R> Result<R> andThen(Function<T, Callable<R>> f);
 
+    /**
+     * Perform the continuation with the value within the success {@code Result}
+     * and return itself.
+     *
+     * <p>Where the {@code Result} is a success, then if an exception is thrown
+     * by the continuation the {@code Result} returned will be a new error
+     * {@code Result} containing that exception, otherwise the original
+     * {@code Result}will be returned.</p>
+
+     * <p>Where the {@code Result} is an error, then the {@code Result} is
+     * returned immediately and the continuation is ignored.</p>
+     *
+     * <pre><code>
+     * Integer doSomething() {...}
+     * void doSomethingElse(final Integer value) {...}
+     * Result&lt;Integer&gt; r = Result.of(() -&gt; doSomething())
+     *                           .thenWith(value -&gt; () -&gt; doSomethingElse(value));
+     * </code></pre>
+     *
+     * @param f the function to map the Success value into the result
+     *          continuation
+     * @return the Result or a new error Result
+     */
+    @API(status = STABLE)
+    Result<T> thenWith(Function<T, WithResultContinuation<T>> f);
+
     /**
      * Perform the continuation with the current Result value then return the current Result, assuming there was no
      * error in the continuation.
      *
      * <pre><code>
-     *     Integer doSomething() {...}
-     *     void doSomethingElse(final Integer value) {...}
-     *     Result&lt;Integer&gt; r = Result.of(() -&gt; doSomething())
-     *                              .thenWith(value -&gt; () -&gt; doSomethingElse(value));
+     * Integer doSomething() {...}
+     * void doSomethingElse(final Integer value) {...}
+     * Result&lt;Integer&gt; r = Result.of(() -&gt; doSomething())
+     *                           .thenWith(value -&gt; () -&gt; doSomethingElse(value));
      * </code></pre>
      *
      * <p>Where the Result is an Err, then the Result is returned immediately and the continuation is ignored.</p>
@@ -304,7 +805,8 @@ public interface Result<T> extends Functor<T, Result<?>> {
      * @param f the function to map the Success value into the result continuation
      * @return the Result or a new error Result
      */
-    Result<T> thenWith(Function<T, WithResultContinuation<T>> f);
+    @API(status = STABLE)
+    ResultVoid thenWithV(Function<T, WithResultContinuation<T>> f);
 
     /**
      * Reduce two Results of the same type into one using the reducing function provided.
@@ -312,9 +814,24 @@ public interface Result<T> extends Functor<T, Result<?>> {
      * <p>If either Result is an error, then the reduce will return the error. If both are errors, then the error of
      * {@code this} Result will be returned.</p>
      *
-     * @param identify the identify Result
+     * @param identify the identity Result
      * @param operator the function to combine the values the Results
      * @return a Result containing the combination of the two Results
      */
+    @API(status = EXPERIMENTAL)
     Result<T> reduce(Result<T> identify, BinaryOperator<T> operator);
+
+    /**
+     * Discard any success value while retaining any error.
+     *
+     * <pre><code>
+     * ResultVoid result = Result.of(() -&gt; getResultValue())
+     *                           .toVoid();
+     * </code></pre>
+     *
+     * @return A {@code SuccessVoid} for a {@code Success} or a {@code ErrVoid} for an {@code Err}.
+     */
+    @API(status = STABLE)
+    ResultVoid toVoid();
+
 }
diff --git a/src/main/java/net/kemitix/mon/result/ResultVoid.java b/src/main/java/net/kemitix/mon/result/ResultVoid.java
new file mode 100644
index 0000000..1d77b3c
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/result/ResultVoid.java
@@ -0,0 +1,134 @@
+package net.kemitix.mon.result;
+
+import org.apiguardian.api.API;
+
+import java.util.concurrent.Callable;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import static org.apiguardian.api.API.Status.STABLE;
+
+/**
+ * A @{link Result} with no value.
+ */
+public interface ResultVoid extends BaseResult {
+
+    /**
+     * Matches the Result, either success or error, and supplies the appropriate
+     * Consumer with the value or error.
+     *
+     * <pre><code>
+     * Result.ok()
+     *       .match(
+     *           () -> doSomething(),
+     *           error -> handleError(error)
+     *       );
+     * </code></pre>
+     *
+     * @param onSuccess the Consumer to pass the value of a successful Result to
+     * @param onError   the Consumer to pass the error from an error Result to
+     */
+    @API(status = STABLE)
+    void match(Runnable onSuccess, Consumer<Throwable> onError);
+
+    /**
+     * Attempts to restore an error {@code ResultVoid} to a success.
+     *
+     * <p>When the Result is already a success, then the result is returned
+     * unmodified.</p>
+     *
+     * <pre><code>
+     * void doSomethingRisky(String s) throws Exception {...}
+     * ResultVoid result = Result.ofVoid(() -> doSomethingRisky("first"))
+     *                           .recover(e -> Result.ofVoid(() -> doSomethingRisky("second")));
+     * </code></pre>
+     *
+     * @param f the function to recover from the error
+     * @return if Result is an error, a new Result, either a Success, or if
+     * recovery is not possible another error. If the Result is already a
+     * success, then this returns itself.
+     */
+    @API(status = STABLE)
+    ResultVoid recover(Function<Throwable, ResultVoid> f);
+
+
+    /**
+     * A handler for success states.
+     *
+     * <pre><code>
+     * void doSomethingRisky() throws Exception {...}
+     * void handleSuccess() {...}
+     * Result.ofVoid(() -> doSomethingRisky()) // ResultVoid
+     *       .onSuccess(() -> handleSuccess());
+     * </code></pre>
+     *
+     * <p>When this is a success then tne Consumer will be supplied with the
+     * success value. When this is an error, then nothing happens.</p>
+     *
+     * @param runnable the call if the Result is a success
+     */
+    @API(status = STABLE)
+    void onSuccess(Runnable runnable);
+
+    /**
+     * A handler for error state, when the error matches the errorClass.
+     *
+     * <p>If the `Result` is an error and that error is an instance of the
+     * errorClass, then supply the error to the `Consumer`. Does nothing if the
+     * error is not an instance of the errorClass, or is a success.</p>
+     *
+     * <p>Similar to the catch block in a try-catch.</p>
+     *
+     * <pre><code>
+     * void handleError(UnsupportedOperationException e) {...}
+     * Result.of(() -&gt; getValue())
+     *       .onError(UnsupportedOperationException.class,
+     *                e -&gt; handleError(e))
+     * </code></pre>
+     *
+     * @param errorClass the class of Throwable to match
+     * @param consumer the consumer to call if it matches
+     * @param <E> the Type of the Throwable to match
+     * @return the original unmodified Result
+     */
+    @API(status = STABLE)
+    <E extends Throwable> ResultVoid onError(
+            Class<E> errorClass,
+            Consumer<E> consumer
+    );
+
+    /**
+     * Execute the callable if the {@code Result} is a success, ignore it if is an error.
+     *
+     * <pre><code>
+     * Result.ofVoid(() -&gt; doSomethingRisky())
+     *       .andThen(() -&gt; doSomethingRisky("again"));
+     * </code></pre>
+     *
+     * @param f   the function to map the Success value into the Callable
+     * @return itself unless the callable fails when it will return a new error Result
+     */
+    @API(status = STABLE)
+    ResultVoid andThen(VoidCallable f);
+
+    /**
+     * Replaces the current Result with the result of the callable.
+     *
+     * <p>Discards the success/error state or the current Result.</p>
+     *
+     * <p>If the callable results in a new error, then that error will be in the returned Result.</p>
+     *
+     * <pre><code>
+     * Result&lt;Integer&gt; result = Result.ofVoid(() -&gt; doSomethingRisky())
+     *                          .inject(() -&gt; 1);
+     * </code></pre>
+     *
+     * @param callable the callable to create the new value
+     * @param <T> the type of the new value
+     * @return a new Result with the result of callable
+     */
+    default <T> Result<T> inject(Callable<T> callable) {
+        return Result.of(callable);
+    }
+
+}
diff --git a/src/main/java/net/kemitix/mon/result/Success.java b/src/main/java/net/kemitix/mon/result/Success.java
index 5c0a13d..89a8c03 100644
--- a/src/main/java/net/kemitix/mon/result/Success.java
+++ b/src/main/java/net/kemitix/mon/result/Success.java
@@ -22,14 +22,12 @@
 package net.kemitix.mon.result;
 
 import lombok.RequiredArgsConstructor;
-import net.kemitix.mon.maybe.Maybe;
 
 import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.Predicate;
 
 /**
  * A Successful Result.
@@ -37,7 +35,8 @@ import java.util.function.Predicate;
  * @param <T> the type of the value in the Result
  */
 @RequiredArgsConstructor
-@SuppressWarnings({"methodcount", "PMD.CyclomaticComplexity"})
+@SuppressWarnings({"methodcount", "PMD.TooManyMethods", "PMD.ExcessivePublicCount",
+        "PMD.CyclomaticComplexity"})
 class Success<T> implements Result<T> {
 
     private final T value;
@@ -54,11 +53,11 @@ class Success<T> implements Result<T> {
 
     @Override
     @SuppressWarnings({"illegalcatch", "PMD.AvoidCatchingThrowable"})
-    public <R> Result<R> map(final Function<T, R> f) {
+    public <R> Result<R> map(final ThrowableFunction<T, R, ?> f) {
         try {
-            return success(f.apply(this.value));
+            return new Success<>(f.apply(value));
         } catch (Throwable e) {
-            return err(e);
+            return new Err<>(e);
         }
     }
 
@@ -67,14 +66,6 @@ class Success<T> implements Result<T> {
         onSuccess.accept(value);
     }
 
-    @Override
-    public Result<Maybe<T>> maybe(final Predicate<T> predicate) {
-        if (predicate.test(value)) {
-            return success(Maybe.just(value));
-        }
-        return success(Maybe.nothing());
-    }
-
     @Override
     public T orElseThrow() {
         return value;
@@ -101,11 +92,24 @@ class Success<T> implements Result<T> {
         return this;
     }
 
+    @Override
+    public void onSuccess(final Consumer<T> successConsumer) {
+        successConsumer.accept(value);
+    }
+
     @Override
     public void onError(final Consumer<Throwable> errorConsumer) {
         // do nothing - this is not an error
     }
 
+    @Override
+    public <E extends Throwable> Result<T> onError(
+            final Class<E> errorClass,
+            final Consumer<E> consumer
+    ) {
+        return this;
+    }
+
     @Override
     public <R> Result<R> andThen(final Function<T, Callable<R>> f) {
         return result(f.apply(value));
@@ -116,6 +120,11 @@ class Success<T> implements Result<T> {
         return f.apply(value).call(this);
     }
 
+    @Override
+    public ResultVoid thenWithV(final Function<T, WithResultContinuation<T>> f) {
+        return f.apply(value).call(this).toVoid();
+    }
+
     @Override
     public Result<T> reduce(final Result<T> identity, final BinaryOperator<T> operator) {
         return flatMap(a -> identity.flatMap(b -> result(() -> operator.apply(a, b))));
@@ -126,6 +135,11 @@ class Success<T> implements Result<T> {
         return f.apply(value);
     }
 
+    @Override
+    public ResultVoid flatMapV(final Function<T, ResultVoid> f) {
+        return f.apply(value);
+    }
+
     @Override
     public boolean equals(final Object other) {
         return other instanceof Success && Objects.equals(value, ((Success) other).value);
@@ -140,4 +154,9 @@ class Success<T> implements Result<T> {
     public String toString() {
         return String.format("Result.Success{value=%s}", value);
     }
+
+    @Override
+    public ResultVoid toVoid() {
+        return SuccessVoid.getInstance();
+    }
 }
diff --git a/src/main/java/net/kemitix/mon/result/SuccessVoid.java b/src/main/java/net/kemitix/mon/result/SuccessVoid.java
new file mode 100644
index 0000000..7d099ea
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/result/SuccessVoid.java
@@ -0,0 +1,91 @@
+package net.kemitix.mon.result;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@SuppressWarnings("PMD.AvoidDuplicateLiterals")
+public class SuccessVoid implements ResultVoid {
+
+    private static final ResultVoid INSTANCE = new SuccessVoid();
+
+    /**
+     * Get the SuccessVoid instance.
+     *
+     * <p>The SuccessVoid, having no value, represents the state of success.</p>
+     *
+     * @return the SuccessVoid
+     */
+    public static ResultVoid getInstance() {
+        return INSTANCE;
+    }
+
+    @Override
+    public boolean isError() {
+        return false;
+    }
+
+    @Override
+    public boolean isOkay() {
+        return true;
+    }
+
+    @Override
+    public void match(final Runnable onSuccess, final Consumer<Throwable> onError) {
+        onSuccess.run();
+    }
+
+    @Override
+    public ResultVoid recover(final Function<Throwable, ResultVoid> f) {
+        return this;
+    }
+
+    @Override
+    public void onSuccess(final Runnable runnable) {
+        runnable.run();
+    }
+
+    @Override
+    public void onError(final Consumer<Throwable> errorConsumer) {
+        // do nothing - this is not an error
+    }
+
+    @Override
+    public <E extends Throwable> ResultVoid onError(
+            final Class<E> errorClass,
+            final Consumer<E> consumer
+    ) {
+        return this;
+    }
+
+    @Override
+    @SuppressWarnings("PMD.AvoidCatchingGenericException")
+    public ResultVoid andThen(final VoidCallable f) {
+        try {
+            f.call();
+            return this;
+        } catch (Exception e) {
+            return new ErrVoid(e);
+        }
+    }
+
+    @Override
+    public boolean equals(final Object other) {
+        return other instanceof SuccessVoid;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(SuccessVoid.class);
+    }
+
+    @Override
+    public String toString() {
+        return "Result.SuccessVoid{}";
+    }
+
+}
diff --git a/src/main/java/net/kemitix/mon/result/ThrowableFunction.java b/src/main/java/net/kemitix/mon/result/ThrowableFunction.java
new file mode 100644
index 0000000..6900f48
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/result/ThrowableFunction.java
@@ -0,0 +1,23 @@
+package net.kemitix.mon.result;
+
+/**
+ * Represents a function that accepts one argument and produces a result.
+ * This is a functional interface whose functional method is apply(Object).
+ *
+ * @param <T> the type of the input to the function
+ * @param <R> the type of the result of the function
+ * @param <E> the type of the exception that could be thrown
+ */
+@FunctionalInterface
+public interface ThrowableFunction<T, R, E extends Throwable> {
+
+    /**
+     * Applies this function to the given argument.
+     *
+     * @param value the function argument
+     * @return the function result
+     * @throws E if the function fails
+     */
+    R apply(T value) throws E;
+
+}
diff --git a/src/main/java/net/kemitix/mon/result/VoidCallable.java b/src/main/java/net/kemitix/mon/result/VoidCallable.java
new file mode 100644
index 0000000..4519962
--- /dev/null
+++ b/src/main/java/net/kemitix/mon/result/VoidCallable.java
@@ -0,0 +1,19 @@
+package net.kemitix.mon.result;
+
+/**
+ * A task that returns void and may throw an exception.
+ *
+ * <p>Implementors define a single method with no arguments called call.
+ * The VoidCallable interface is similar to {@link java.util.concurrent.Callable},
+ * but does not return a value.</p>
+ */
+@FunctionalInterface
+public interface VoidCallable {
+    /**
+     * Executes and may throw an exception.
+     *
+     * @throws Exception if unable to complete
+     */
+    @SuppressWarnings("PMD.SignatureDeclareThrowsException")
+    void call() throws Exception;
+}
diff --git a/src/main/java/net/kemitix/mon/result/WithResultContinuation.java b/src/main/java/net/kemitix/mon/result/WithResultContinuation.java
index e4baa8c..46412de 100644
--- a/src/main/java/net/kemitix/mon/result/WithResultContinuation.java
+++ b/src/main/java/net/kemitix/mon/result/WithResultContinuation.java
@@ -21,6 +21,8 @@
 
 package net.kemitix.mon.result;
 
+import net.kemitix.mon.TypeReference;
+
 /**
  * A Callable-like interface for performing an action with a Result that, if there are no errors is returned as-is, but
  * if there is an error then a new error Result is returned.
@@ -50,7 +52,7 @@ public interface WithResultContinuation<T> {
         try {
             run();
         } catch (Throwable e) {
-            return Result.error(e);
+            return Result.error(TypeReference.create(), e);
         }
         return currentResult;
     }
diff --git a/src/main/java/net/kemitix/mon/result/package-info.java b/src/main/java/net/kemitix/mon/result/package-info.java
index b9f390a..61fb32e 100644
--- a/src/main/java/net/kemitix/mon/result/package-info.java
+++ b/src/main/java/net/kemitix/mon/result/package-info.java
@@ -20,9 +20,28 @@
  */
 
 /**
- * An experiment in creating something similar to a Type-Alias in Java.
+ * <h1>Result</h1>
  *
- * <p>Ideas initially lifted from the Design with Types series at https://fsharpforfunandprofit.com/</p>
+ * Allows handling error conditions without the need to {@code catch}
+ * exceptions.
+ *
+ * <p>When a {@link Result} is returned from a method, it will be in one of two
+ * states: {@link Success} or {@link Err}. The {@code Success} state will
+ * contain a value from the method. The {@code Err} state will contain a
+ * {@link java.lang.Throwable} detailing the reason for the failure.</p>
+ *
+ * <p>Methods returning a {@code Result} should not throw any exceptions.</p>
+ *
+ * <p>{@code Result} is a Monad.</p>
+ *
+ * <h2>Static Constructors:</h2>
+ * <ul>
+ *     <li>{@link Result#ok()}</li>
+ *     <li>{@link Result#ok(Object)}</li>
+ *     <li>{@link Result#of(Callable)}</li>
+ *     <li>{@link Result#ofVoid(VoidCallable)}</li>
+ *     <li>{@link Result#error(Throwable)}</li>
+ * </ul>
  *
  * @author Paul Campbell (pcampbell@kemitix.net)
  */
diff --git a/src/test/java/net/kemitix/mon/MaybeTest.java b/src/test/java/net/kemitix/mon/MaybeTest.java
index 4da89c9..383db36 100644
--- a/src/test/java/net/kemitix/mon/MaybeTest.java
+++ b/src/test/java/net/kemitix/mon/MaybeTest.java
@@ -114,11 +114,17 @@ class MaybeTest implements WithAssertions {
     }
 
     @Test
-    void fromOptional() {
+    void mapFromOptional() {
         assertThat(Optional.of(1).map(Maybe::just).orElseGet(Maybe::nothing)).isEqualTo(just(1));
         assertThat(Optional.empty().map(Maybe::just).orElseGet(Maybe::nothing)).isEqualTo(nothing());
     }
 
+    @Test
+    void fromOptional() {
+        assertThat(Maybe.fromOptional(Optional.of(1))).isEqualTo(just(1));
+        assertThat(Maybe.fromOptional(Optional.empty())).isEqualTo(nothing());
+    }
+
     @Test
     void peek() {
         final AtomicInteger ref = new AtomicInteger(0);
diff --git a/src/test/java/net/kemitix/mon/ResultTest.java b/src/test/java/net/kemitix/mon/ResultTest.java
index 231702b..0b92742 100644
--- a/src/test/java/net/kemitix/mon/ResultTest.java
+++ b/src/test/java/net/kemitix/mon/ResultTest.java
@@ -1,805 +1,2277 @@
 package net.kemitix.mon;
 
 import lombok.RequiredArgsConstructor;
+import net.kemitix.mon.experimental.either.Either;
 import net.kemitix.mon.maybe.Maybe;
 import net.kemitix.mon.result.CheckedErrorResultException;
 import net.kemitix.mon.result.ErrorResultException;
-import net.kemitix.mon.result.UnexpectedErrorResultException;
 import net.kemitix.mon.result.Result;
+import net.kemitix.mon.result.ResultVoid;
+import net.kemitix.mon.result.SuccessVoid;
+import net.kemitix.mon.result.UnexpectedErrorResultException;
+import net.kemitix.mon.result.VoidCallable;
 import org.assertj.core.api.WithAssertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
 
 class ResultTest implements WithAssertions {
 
-    @Test
-    void equality() {
-        assertThat(Result.ok(1)).isEqualTo(Result.ok(1));
-        assertThat(Result.ok(1)).isNotEqualTo(Result.ok(2));
-        final RuntimeException runtimeException = new RuntimeException();
-        assertThat(Result.ok(1)).isNotEqualTo(Result.error(runtimeException));
-        assertThat(Result.error(runtimeException)).isEqualTo(Result.error(runtimeException));
-        assertThat(Result.error(runtimeException)).isNotEqualTo(Result.error(new RuntimeException()));
-        assertThat(Result.ok(1).equals("1")).isFalse();
-        assertThat(Result.error(new RuntimeException()).equals("1")).isFalse();
+    @Nested
+    @DisplayName("Basic Properties")
+    class BasicPropertiesTests {
+
+        @Test
+        @SuppressWarnings({"PMD.JUnitTestContainsTooManyAsserts"})
+        void equality() {
+            final RuntimeException runtimeException = new RuntimeException();
+            // Success
+            assertThat(Result.ok(1)).as("Success: same integer value").isEqualTo(Result.ok(1));
+            assertThat(Result.ok(1)).as("Success: diff integer values").isNotEqualTo(Result.ok(2));
+            assertThat(Result.ok(1).equals("1")).as("Success: string v integer").isFalse(); // NOPMD
+            assertThat(Result.ok(1)).as("Success: success v error").isNotEqualTo(Result.error(runtimeException));
+            // SuccessVoid
+            assertThat(Result.ok()).as("SuccessVoid: void v void").isEqualTo(Result.ok());
+            assertThat(Result.ok().hashCode()).as("SuccessVoid: hash v void").isNotNull();
+            assertThat(Result.ok()).as("SuccessVoid: void v integer").isNotEqualTo(Result.ok(1));
+            assertThat(Result.ok()).as("SuccessVoid: v ErrVoid").isNotEqualTo(Result.error(runtimeException));
+            // Error
+            TypeReference<Integer> integerReference = TypeReference.create();
+            assertThat(Result.error(integerReference, runtimeException)).as("error v error").isEqualTo(Result.error(integerReference, runtimeException));
+            assertThat(Result.error(integerReference, runtimeException)).as("error v other error").isNotEqualTo(Result.error(integerReference, new RuntimeException()));
+            assertThat(Result.error(integerReference, runtimeException)).as("error v string").isNotEqualTo("1");
+            // ErrorVoid
+            assertThat(Result.error(runtimeException)).as("same error value").isEqualTo(Result.error(runtimeException));
+            assertThat(Result.error(runtimeException)).as("diff error values").isNotEqualTo(Result.error(new RuntimeException()));
+            assertThat(Result.error(new RuntimeException()).equals("1")).as("error v string").isFalse(); // NOPMD
+        }
+
+        @Test
+        void successHashCodesAreUnique() {
+            assertThat(Result.ok(1).hashCode()).isNotEqualTo(Result.ok(2).hashCode());
+        }
+
+        @Test
+        void errorHashCodesAreUnique() {
+            // despite having 'equivalent' exceptions, the exceptions are distinct instances, so should be considered unique
+            //given
+            final RuntimeException exception1 = new RuntimeException("message");
+            final RuntimeException exception2 = new RuntimeException("message");
+            assumeThat(exception1.hashCode()).isNotEqualTo(exception2.hashCode());
+            //then
+            assertThat(Result.error(exception1).hashCode()).isNotEqualTo(Result.error(exception2).hashCode());
+        }
+
+        @Test
+        void errorVHashCodesAreUnique() {
+            // despite having 'equivalent' exceptions, the exceptions are distinct instances, so should be considered unique
+            //given
+            final RuntimeException exception1 = new RuntimeException("message");
+            final RuntimeException exception2 = new RuntimeException("message");
+            assumeThat(exception1.hashCode()).isNotEqualTo(exception2.hashCode());
+            TypeReference<Integer> integerReference = TypeReference.create();
+            //then
+            assertThat(Result.error(integerReference, exception1).hashCode())
+                    .isNotEqualTo(Result.error(integerReference, exception2).hashCode());
+        }
+
+        @Test
+        void whenOkVoid_isOkay() {
+            //when
+            var result = Result.ok();
+            //then
+            assertThat(result.isOkay()).isTrue();
+        }
+
+        @Test
+        void whenOkVoid_isError() {
+            //when
+            var result = Result.ok();
+            //then
+            assertThat(result.isError()).isFalse();
+        }
+
+        @Test
+        void whenOkayVoid_match_isNull() {
+            //when
+            var result = Result.ok();
+            //then
+            result.match(
+                    () -> assertThat(true).isTrue(),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void whenOk_isOkay() {
+            //when
+            final Result<String> result = Result.ok("good");
+            //then
+            assertThat(result.isOkay()).isTrue();
+        }
+
+        @Test
+        void whenOkay_isNotError() {
+            //when
+            final Result<String> result = Result.ok("good");
+            //then
+            assertThat(result.isError()).isFalse();
+        }
+
+        @Test
+        void whenOkay_matchSuccess() {
+            //given
+            final Result<String> result = Result.ok("good");
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo("good"),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void whenError_isError() {
+            //when
+            final Result<Integer> result = anError(new Exception());
+            //then
+            assertThat(result.isOkay()).isFalse();
+        }
+
+        @Test
+        void whenError_isNotSuccess() {
+            //when
+            final Result<Integer> result = anError(new Exception());
+            //then
+            assertThat(result.isError()).isTrue();
+        }
+
+        @Test
+        void whenError_matchError() {
+            //given
+            final Result<Integer> result = anError(new Exception("bad"));
+            //then
+            result.match(
+                    success -> fail("not a success"),
+                    error -> assertThat(error.getMessage()).isEqualTo("bad")
+            );
+        }
+
+        @Test
+        void okay_toString() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final String toString = ok.toString();
+            //then
+            assertThat(toString).contains("Result.Success{value=1}");
+        }
+
+        @Test
+        void okayVoid_toString() {
+            //given
+            final ResultVoid ok = Result.ok();
+            //when
+            final String toString = ok.toString();
+            //then
+            assertThat(toString).contains("Result.SuccessVoid{}");
+        }
+
+        @Test
+        void error_toString() {
+            //given
+            final Result<Integer> error = anError(new RuntimeException("failed"));
+            //when
+            final String toString = error.toString();
+            //then
+            assertThat(toString).contains("Result.Error{error=java.lang.RuntimeException: failed}");
+        }
+
+        @Test
+        void errorVoid_toString() {
+            //given
+            final ResultVoid error = Result.error(new RuntimeException("failed"));
+            //when
+            final String toString = error.toString();
+            //then
+            assertThat(toString).contains("Result.ErrVoid{error=java.lang.RuntimeException: failed}");
+        }
+
+        @Test
+        void value_whenResultOf_isOkay() {
+            //given
+            final Callable<String> c = () -> "okay";
+            //when
+            final Result<String> result = Result.of(c);
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo("okay"),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void exception_whenResultOf_isError() {
+            //given
+            final Callable<String> c = () -> {
+                throw new IOException();
+            };
+            //when
+            final Result<String> result = Result.of(c);
+            //then
+            result.match(
+                    success -> fail("not a success"),
+                    error -> assertThat(error).isInstanceOf(IOException.class)
+            );
+        }
     }
 
-    @Test
-    void successHashCodesAreUnique() {
-        assertThat(Result.ok(1).hashCode()).isNotEqualTo(Result.ok(2).hashCode());
+    private Result<Integer> anError(Exception e) {
+        return Result.ok(1)
+                .flatMap(s -> Result.of(() -> {throw e;}));
     }
 
-    @Test
-    void errorHashCodesAreUnique() {
-        // despite having 'equivalent' exceptions, the exceptions are distinct instances, so should be considered unique
-        //given
-        final RuntimeException exception1 = new RuntimeException("message");
-        final RuntimeException exception2 = new RuntimeException("message");
-        assumeThat(exception1.hashCode()).isNotEqualTo(exception2.hashCode());
-        //then
-        assertThat(Result.error(exception1).hashCode()).isNotEqualTo(Result.error(exception2).hashCode());
+    @Nested
+    @DisplayName("flatMap")
+    class FlatMapTests {
+        @Test
+        void okay_whenFlatMapToOkay_isOkay() {
+            //given
+            final Result<String> ok = Result.ok("good");
+            //when
+            final Result<String> result = ok.flatMap(v -> Result.ok(v.toUpperCase()));
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo("GOOD"),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void okay_whenFlatMapToError_isError() {
+            //given
+            final Result<String> result = Result.ok("good");
+            //when
+            final Result<Integer> flatMap = result.flatMap(v -> anError(new Exception("bad flat map")));
+            //then
+            assertThat(flatMap.isOkay()).isFalse();
+        }
+
+        @Test
+        void error_whenFlatMapToOkay_isError() {
+            //given
+            final Result<Integer> result = anError(new Exception("bad"));
+            //when
+            final Result<Object> flatMap = result.flatMap(Result::ok);
+            //then
+            assertThat(flatMap.isError()).isTrue();
+        }
+
+        @Test
+        void error_whenFlatMapToError_isError() {
+            //given
+            final Result<Integer> result = anError(new Exception("bad"));
+            //when
+            final Result<Integer> flatMap = result.flatMap(v -> anError(new Exception("bad flat map")));
+            //then
+            assertThat(flatMap.isError()).isTrue();
+        }
     }
 
-    @Test
-    void whenOk_isOkay() {
-        //when
-        final Result<String> result = Result.ok("good");
-        //then
-        assertThat(result.isOkay()).isTrue();
+    @Nested
+    @DisplayName("flatMapV")
+    class FlatMapVTests {
+        @Test
+        void okay_whenFlatMapVToOkay_isOkayVoid() {
+            //given
+            final Result<String> result = Result.ok("good");
+            //when
+            final ResultVoid flatMap = result.flatMapV(v -> Result.ok());
+            //then
+            flatMap.match(
+                    () -> assertThat(true).isTrue(),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void okay_whenFlatMapVToError_isErrorVoid() {
+            //given
+            final Result<String> result = Result.ok("good");
+            //when
+            final ResultVoid flatMap = result.flatMapV(v -> Result.error(new Exception("bad flat map")));
+            //then
+            assertThat(flatMap.isOkay()).isFalse();
+        }
+
+        @Test
+        void error_whenFlatMapVToOkay_isErrorVoid() {
+            //given
+            final Result<Integer> result = anError(new Exception("bad"));
+            //when
+            final ResultVoid flatMap = result.flatMapV(value -> Result.ok());
+            //then
+            assertThat(flatMap.isError()).isTrue();
+        }
+
+        @Test
+        void error_whenFlatMapVToError_isErrorVoid() {
+            //given
+            final Result<Integer> result = anError(new Exception("bad"));
+            //when
+            final ResultVoid flatMap = result.flatMapV(v -> Result.error(new Exception("bad flat map")));
+            //then
+            assertThat(flatMap.isError()).isTrue();
+        }
     }
 
-    @Test
-    void whenOkay_isNotError() {
-        //when
-        final Result<String> result = Result.ok("good");
-        //then
-        assertThat(result.isError()).isFalse();
+    @Nested
+    @DisplayName("map")
+    class MapTest {
+        @Test
+        void okay_whenMapToOkay_isOkay() {
+            //given
+            final Result<Integer> okResult = Result.ok(1);
+            //when
+            final Result<String> result = okResult.map(value -> String.valueOf(value));
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo("1"),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void okay_whenMapToError_isError() {
+            //given
+            final Result<Integer> okResult = Result.ok(1);
+            //when
+            final Result<String> result = okResult.map(value -> {
+                throw new RuntimeException("map error");
+            });
+            //then
+            result.match(
+                    success -> fail("not an success"),
+                    error -> assertThat(error).hasMessage("map error")
+            );
+        }
+
+        @Test
+        void error_whenMap_isError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> errorResult = anError(exception);
+            //when
+            final Result<String> result = errorResult.map(value -> String.valueOf(value));
+            //then
+            result.match(
+                    success -> fail("not an success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
     }
 
-    @Test
-    void whenOkay_matchSuccess() {
-        //given
-        final Result<String> result = Result.ok("good");
-        //then
-        result.match(
-                success -> assertThat(success).isEqualTo("good"),
-                error -> fail("not an error")
-        );
+    @Nested
+    @DisplayName("maybe")
+    class MaybeTests {
+
+        @Nested
+        @DisplayName("fromMaybe")
+        class FromMaybeTests {
+
+            @Test
+            void just_whenFromMaybe_isOkay() {
+                //given
+                final Maybe<Integer> just = Maybe.just(1);
+                //when
+                final Result<Integer> result = Result.from(just, () -> new RuntimeException());
+                //then
+                result.match(
+                        success -> assertThat(success).isEqualTo(1),
+                        error -> fail("not an error")
+                );
+            }
+
+            @Test
+            void nothing_whenFromMaybe_isError() {
+                //given
+                final Maybe<Object> nothing = Maybe.nothing();
+                final RuntimeException exception = new RuntimeException();
+                //when
+                final Result<Object> result = Result.from(nothing, () -> exception);
+                //then
+                result.match(
+                        success -> fail("not a success"),
+                        error -> assertThat(error).isSameAs(exception)
+                );
+            }
+        }
+
+        @Nested
+        @DisplayName("toMaybe")
+        class ToMaybeTests {
+
+            @Test
+            void okay_whenToMaybe_isJust() {
+                //given
+                final Result<Integer> ok = Result.ok(1);
+                //when
+                final Maybe<Integer> maybe = Result.toMaybe(ok);
+                //then
+                assertThat(maybe.toOptional()).contains(1);
+            }
+
+            @Test
+            void error_whenToMaybe_isNothing() {
+                //given
+                final Result<Integer> error = anError(new RuntimeException());
+                //when
+                final Maybe<Integer> maybe = Result.toMaybe(error);
+                //then
+                assertThat(maybe.toOptional()).isEmpty();
+            }
+        }
     }
 
-    @Test
-    void whenError_isError() {
-        //when
-        final Result<String> result = Result.error(new Exception());
-        //then
-        assertThat(result.isOkay()).isFalse();
+    @Nested
+    @DisplayName("orElseThrow")
+    class OrElseThrowTests {
+        @Test
+        void okay_whenOrElseThrow_isValue() throws Throwable {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final Integer value = ok.orElseThrow();
+            //then
+            assertThat(value).isEqualTo(1);
+        }
+
+        @Test
+        void error_whenOrElseThrow_throws() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            assertThatThrownBy(() -> error.orElseThrow())
+                    .isInstanceOf(CheckedErrorResultException.class)
+                    .hasCause(exception);
+        }
+
+        @Test
+        void okay_whenOrElseThrowT_isValue() throws Exception {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final Integer value = ok.orElseThrow(Exception.class);
+            //then
+            assumeThat(value).isEqualTo(1);
+        }
+
+        @Test
+        void errorT_whenOrElseThrowT_throwsT() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //then
+            assertThatThrownBy(() -> error.orElseThrow(RuntimeException.class)).isSameAs(exception);
+        }
+
+        @Test
+        void errorR_whenOrElseThrowT_throwsWrappedR() {
+            //given
+            final IOException exception = new IOException();
+            final Result<Integer> error = anError(exception);
+            //then
+            assertThatThrownBy(() -> error.orElseThrow(RuntimeException.class))
+                    .isInstanceOf(UnexpectedErrorResultException.class)
+                    .hasCause(exception);
+        }
     }
 
-    @Test
-    void whenError_isNotSuccess() {
-        //when
-        final Result<String> result = Result.error(new Exception());
-        //then
-        assertThat(result.isError()).isTrue();
+    @Nested
+    @DisplayName("orElseThrowUnchecked")
+    class OrElseThrowUncheckedTests {
+        @Test
+        void okay_whenOrElseThrowUnchecked_isValue() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final Integer value = ok.orElseThrowUnchecked();
+            //then
+            assumeThat(value).isEqualTo(1);
+        }
+
+        @Test
+        void error_whenOrElseThrowUnchecked_throwsWrapped() {
+            //given
+            final IOException exception = new IOException();
+            final Result<Integer> error = anError(exception);
+            //then
+            assertThatThrownBy(() -> error.orElseThrowUnchecked())
+                    .isInstanceOf(ErrorResultException.class)
+                    .hasCause(exception);
+        }
     }
 
-    @Test
-    void whenError_matchError() {
-        //given
-        final Result<Object> result = Result.error(new Exception("bad"));
-        //then
-        result.match(
-                success -> fail("not a success"),
-                error -> assertThat(error.getMessage()).isEqualTo("bad")
-        );
+    @Nested
+    @DisplayName("invert")
+    class InvertTests {
+        @Test
+        void justOkay_whenInvert_thenOkayJust() {
+            //given
+            final Maybe<Result<Integer>> justSuccess = Maybe.just(Result.ok(1));
+            //when
+            final Result<Maybe<Integer>> result = Result.swap(justSuccess);
+            //then
+            result.match(
+                    success -> assertThat(success.toOptional()).contains(1),
+                    error -> fail("Not an error")
+            );
+        }
+
+        @Test
+        void JustError_whenInvert_isError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Maybe<Result<Integer>> justError = Maybe.just(anError(exception));
+            //when
+            final Result<Maybe<Integer>> result = Result.swap(justError);
+            //then
+            result.match(
+                    success -> fail("Not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Test
+        void nothing_whenInvert_thenOkayNothing() {
+            //given
+            final Maybe<Result<Integer>> nothing = Maybe.nothing();
+            //when
+            final Result<Maybe<Integer>> result = Result.swap(nothing);
+            //then
+            result.match(
+                    success -> assertThat(success.toOptional()).isEmpty(),
+                    error -> fail("Not an error")
+            );
+        }
     }
 
-    @Test
-    void okay_whenFlatMapToOkay_isOkay() {
-        //given
-        final Result<String> result = Result.ok("good");
-        //when
-        final Result<String> flatMap = result.flatMap(v -> Result.ok(v.toUpperCase()));
-        //then
-        assertThat(flatMap.isOkay()).isTrue();
-        flatMap.match(
-                success -> assertThat(success).isEqualTo("GOOD"),
-                error -> fail("not an error")
-        );
+    @Nested
+    @DisplayName("use cases")
+    class UseCaseTests {
+        @Test
+        void useCase_whenOkay_thenReturnSuccess() {
+            //given
+            final UseCase useCase = UseCase.isOkay();
+            //when
+            final Result<Double> doubleResult = useCase.businessOperation("file a", "file bc");
+            //then
+            doubleResult.match(
+                    success -> assertThat(success).isEqualTo(7.5),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        void useCase_whenFirstReadIsError_thenReturnError() {
+            //given
+            final UseCase useCase = UseCase.firstReadInvalid();
+            //when
+            final Result<Double> doubleResult = useCase.businessOperation("file def", "file ghij");
+            //then
+            doubleResult.match(
+                    success -> fail("not okay"),
+                    error -> assertThat(error)
+                            .isInstanceOf(RuntimeException.class)
+                            .hasMessage("file def")
+            );
+        }
+
+        @Test
+        void useCase_whenSecondReadIsError_thenReturnError() {
+            //given
+            final UseCase useCase = UseCase.secondReadInvalid();
+            //when
+            final Result<Double> doubleResult = useCase.businessOperation("file klmno", "file pqrstu");
+            //then
+            doubleResult.match(
+                    success -> fail("not okay"),
+                    error -> assertThat(error)
+                            .isInstanceOf(RuntimeException.class)
+                            .hasMessage("file klmno")
+            );
+        }
     }
 
-    @Test
-    void okay_whenFlatMapToError_isError() {
-        //given
-        final Result<String> result = Result.ok("good");
-        //when
-        final Result<String> flatMap = result.flatMap(v -> Result.error(new Exception("bad flat map")));
-        //then
-        assertThat(flatMap.isOkay()).isFalse();
+    @Nested
+    @DisplayName("peek")
+    class PeekTests {
+        @Test
+        void okay_whenPeek_isConsumed() {
+            //given
+            final Result<Integer> okay = Result.ok(1);
+            final AtomicBoolean consumed = new AtomicBoolean(false);
+            //when
+            okay.peek(v -> consumed.set(true));
+            //then
+            assertThat(consumed).isTrue();
+        }
+
+        @Test
+        void okay_whenPeek_isOriginal() {
+            //given
+            final Result<Integer> okay = Result.ok(1);
+            final AtomicBoolean consumed = new AtomicBoolean(false);
+            //when
+            final Result<Integer> result = okay.peek(v -> consumed.set(true));
+            //then
+            assertThat(result).isSameAs(okay);
+        }
+
+        @Test
+        void error_whenPeek_isNotConsumed() {
+            //given
+            final Result<Integer> error = anError(new RuntimeException());
+            final AtomicBoolean consumed = new AtomicBoolean(false);
+            //when
+            error.peek(newValue -> consumed.set(true));
+            //then
+            assertThat(consumed).isFalse(); // peek should not occur
+        }
+        @Test
+        void error_whenPeek_isSelf() {
+            //given
+            final Result<Integer> error = anError(new RuntimeException());
+            final AtomicBoolean consumed = new AtomicBoolean(false);
+            //when
+            final Result<Integer> result = error.peek(v -> consumed.set(true));
+            //then
+            assertThat(result).isSameAs(error);
+        }
     }
 
-    @Test
-    void error_whenFlatMapToOkay_isError() {
-        //given
-        final Result<String> result = Result.error(new Exception("bad"));
-        //when
-        final Result<String> flatMap = result.flatMap(v -> Result.ok(v.toUpperCase()));
-        //then
-        assertThat(flatMap.isError()).isTrue();
+    @Nested
+    @DisplayName("onError - all error")
+    class OnErrorTests {
+        @Test
+        void okay_whenOnError_isIgnored() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            ok.onError(e -> fail("not an error"));
+        }
+
+        @Test
+        void error_whenOnError_isConsumed() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            final AtomicReference<Throwable> capture = new AtomicReference<>();
+            //when
+            error.onError(capture::set);
+            //then
+            assertThat(capture).hasValue(exception);
+        }
+
+        @Test
+        void okayVoid_whenOnError_isIgnored() {
+            //given
+            final ResultVoid ok = Result.ok();
+            //when
+            ok.onError(e -> fail("not an error"));
+        }
+
+        @Test
+        void errorVoid_whenOnError_isConsumed() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final ResultVoid error = Result.error(exception);
+            final AtomicReference<Throwable> capture = new AtomicReference<>();
+            //when
+            error.onError(capture::set);
+            //then
+            assertThat(capture).hasValue(exception);
+        }
     }
 
-    @Test
-    void error_whenFlatMapToError_isError() {
-        //given
-        final Result<String> result = Result.error(new Exception("bad"));
-        //when
-        final Result<String> flatMap = result.flatMap(v -> Result.error(new Exception("bad flat map")));
-        //then
-        assertThat(flatMap.isError()).isTrue();
+    @Nested
+    @DisplayName("onError - by type")
+    class OnErrorByTypeTests {
+
+        @Test
+        @DisplayName("okay when on error is ignored")
+        void okay_whenOnError_isIgnored() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            ok.onError(Throwable.class,
+                    e -> fail("not an error"));
+        }
+
+        @Test
+        @DisplayName("error with matching type is consumed")
+        void error_whenOnError_isConsumed() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            final AtomicReference<Throwable> capture = new AtomicReference<>();
+            //when
+            error.onError(RuntimeException.class,
+                    capture::set);
+            //then
+            assertThat(capture).hasValue(exception);
+        }
+
+        @Test
+        @DisplayName("error with non-matching type is ignored")
+        void error_withNoMatch_whenOnError_isIgnored() {
+            //given
+            RuntimeException exception = new RuntimeException();
+            Result<Integer> error = anError(exception);
+            final AtomicReference<Throwable> capture = new AtomicReference<>();
+            //when
+            error.onError(Exception.class,
+                    capture::set);
+            //then
+            assertThat(capture).hasValue(null);
+        }
+
+        @Test
+        @DisplayName("okay void when on error is ignored")
+        void okayVoid_whenOnError_isIgnored() {
+            //given
+            final ResultVoid ok = Result.ok();
+            //when
+            ok.onError(Throwable.class,
+                    e -> fail("not an error"));
+        }
+
+        @Test
+        @DisplayName("error void with matching type is consumed")
+        void errorVoid_whenOnError_isConsumed() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final ResultVoid error = Result.error(exception);
+            final AtomicReference<Throwable> capture = new AtomicReference<>();
+            //when
+            error.onError(RuntimeException.class,
+                    capture::set);
+            //then
+            assertThat(capture).hasValue(exception);
+        }
+
+        @Test
+        @DisplayName("error void with non-matching type is ignored")
+        void errorVoid_withNoMatch_whenOnError_isIgnored() {
+            //given
+            RuntimeException exception = new RuntimeException();
+            ResultVoid error = Result.error(exception);
+            final AtomicReference<Throwable> capture = new AtomicReference<>();
+            //when
+            error.onError(Exception.class,
+                    capture::set);
+            //then
+            assertThat(capture).hasValue(null);
+        }
     }
 
-    @Test
-    void okay_whenMapToOkay_isOkay() {
-        //given
-        final Result<Integer> okResult = Result.ok(1);
-        //when
-        final Result<String> result = okResult.map(value -> String.valueOf(value));
-        //then
-        assertThat(result.isOkay()).isTrue();
-        result.match(
-                success -> assertThat(success).isEqualTo("1"),
-                error -> fail("not an error")
-        );
+    @Nested
+    @DisplayName("onSuccess")
+    class OnSuccessTests {
+        @Test
+        void error_whenOnSuccess_isIgnored() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            error.onSuccess(e -> fail("not a success"));
+        }
+
+        @Test
+        void okay_whenOnSuccess_isConsumed() {
+            //given
+            final AtomicReference<Integer> capture = new AtomicReference<>();
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            ok.onSuccess(capture::set);
+            //then
+            assertThat(capture).hasValue(1);
+        }
+
+        @Test
+        void errorVoid_whenOnSuccess_isIgnored() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final ResultVoid error = Result.error(exception);
+            //when
+            error.onSuccess(() -> fail("not a success"));
+        }
+
+        @Test
+        void okayVoid_whenOnSuccess_isConsumed() {
+            //given
+            final AtomicReference<Integer> capture = new AtomicReference<>();
+            final ResultVoid ok = Result.ok();
+            //when
+            ok.onSuccess(() -> capture.set(1));
+            //then
+            assertThat(capture).hasValue(1);
+        }
     }
 
-    @Test
-    void okay_whenMapToError_isError() {
-        //given
-        final Result<Integer> okResult = Result.ok(1);
-        //when
-        final Result<String> result = okResult.map(value -> {
-            throw new RuntimeException("map error");
-        });
-        //then
-        assertThat(result.isError()).isTrue();
-        result.match(
-                success -> fail("not an success"),
-                error -> assertThat(error).hasMessage("map error")
-        );
+    @Nested
+    @DisplayName("recover")
+    class RecoverTests {
+        @Nested @DisplayName("Result")
+        class ResultRecoveryTests {
+            @Test
+            void okay_whenRecover_thenNoChange() {
+                //given
+                final Result<Integer> ok = Result.ok(1);
+                //when
+                final Result<Integer> recovered = ok.recover(e -> Result.ok(2));
+                //then
+                assertThat(recovered).isSameAs(ok);
+            }
+
+            @Test
+            void error_whenRecover_isSuccess() {
+                //given
+                final Result<Integer> error = anError(new RuntimeException());
+                //when
+                // recover can't change the type of the result
+                final Result<Integer> recovered = error.recover(e -> Result.ok(2));
+                //then
+                recovered.peek(v -> assertThat(v).isEqualTo(2));
+            }
+
+            @Test
+            void error_whenRecover_whereError_isUpdatedError() {
+                //given
+                final Result<Integer> error = anError(new RuntimeException("original"));
+                //when
+                final Result<Integer> recovered = error.recover(e -> anError(new RuntimeException("updated")));
+                //then
+                recovered.onError(e -> assertThat(e).hasMessage("updated"));
+            }
+        }
+        @Nested @DisplayName("ResultVoid")
+        class ResultVoidRecoveryTests {
+            @Test
+            void okayVoid_whenRecover_thenNoChange() {
+                //given
+                final ResultVoid ok = Result.ok();
+                //when
+                final ResultVoid recovered = ok.recover(e -> Result.ok());
+                //then
+                assertThat(recovered).isSameAs(ok);
+            }
+
+            @Test
+            void error_whenRecover_isSuccess() {
+                //given
+                final ResultVoid error = Result.error(new RuntimeException());
+                //when
+                // recover can't change the type of the result
+                final ResultVoid recovered = error.recover(e -> Result.ok());
+                //then
+                assertThat(recovered.isOkay()).isTrue();
+            }
+
+            @Test
+            void error_whenRecover_whereError_isUpdatedError() {
+                //given
+                final ResultVoid error = Result.error(new RuntimeException("original"));
+                //when
+                final ResultVoid recovered = error.recover(e -> Result.error(new RuntimeException("updated")));
+                //then
+                recovered.onError(e -> assertThat(e).hasMessage("updated"));
+            }
+        }
     }
 
-    @Test
-    void error_whenMap_isError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> errorResult = Result.error(exception);
-        //when
-        final Result<String> result = errorResult.map(value -> String.valueOf(value));
-        //then
-        assertThat(result.isError()).isTrue();
-        result.match(
-                success -> fail("not an success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
+    @Nested
+    @DisplayName("inject (recover for ResultVoid)")
+    class InjectTests {
+        @Test
+        @DisplayName("SuccessVoid#inject is Success with Value")
+        void okayVoid_whenInject_isOkayValue() {
+            //given
+            final ResultVoid ok = Result.ok();
+            //when
+            final Result<Integer> result = ok.inject(() -> 1);
+            //then
+            assertThat(result).isEqualTo(Result.ok(1));
+        }
+
+        @Test
+        @DisplayName("okayVoid when Inject fails then error")
+        void okayVoid_whenInjectIsError_isError() {
+            //given
+            final ResultVoid ok = Result.ok();
+            //when
+            final Result<Integer> result = ok.inject(() -> {throw new RuntimeException();});
+            //then
+            assertThat(result.isError()).isTrue();
+        }
+
+        @Test
+        @DisplayName("errorVoid when inject is Success with Value")
+        void errorVoid_whenInject_isInjectedValue() {
+            //given
+            final ResultVoid error = Result.error(new RuntimeException());
+            //when
+            final Result<Integer> result = error.inject(() -> 1);
+            //then
+            assertThat(result).isEqualTo(Result.ok(1));
+        }
+
+        @Test
+        @DisplayName("errorVoid when Inject fails then new error")
+        void errorVoid_whenInjectIsError_isNewError() {
+            //given
+            final ResultVoid error = Result.error(new RuntimeException());
+            RuntimeException exception = new RuntimeException();
+            //when
+            final Result<Integer> result = error.inject(() -> {throw exception;});
+            //then
+            result.match(
+                    x -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
     }
 
-    @Test
-    void okay_whenMaybe_wherePasses_isOkayJust() {
-        //given
-        final Result<Integer> okResult = Result.ok(1);
-        //when
-        final Result<Maybe<Integer>> maybeResult = okResult.maybe(value -> value >= 0);
-        //then
-        assertThat(maybeResult.isOkay()).isTrue();
-        maybeResult.match(
-                success -> assertThat(success.toOptional()).contains(1),
-                error -> fail("not an error")
-        );
+    @Nested
+    @DisplayName("andThen")
+    class AndThenTests {
+        @Test
+        void okay_whenAndThen_whereSuccess_isUpdatedSuccess() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final Result<String> result = ok.andThen(v -> () -> "success");
+            //then
+            result.match(
+                    v -> assertThat(v).isEqualTo("success"),
+                    e -> fail("not an error"));
+        }
+
+        @Test
+        void okay_whenAndThen_whereError_isError() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            final RuntimeException exception = new RuntimeException();
+            //when
+            final Result<Object> result = ok.andThen(v -> () -> {
+                throw exception;
+            });
+            //then
+            result.match(
+                    x -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
+        @Test
+        void error_whereAndThen_whereSuccess_isError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            final Result<Object> result = error.andThen(v -> () -> "success");
+            //then
+            result.match(
+                    x -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
+        @Test
+        void error_whenAndThen_whereError_isOriginalError() {
+            //given
+            final RuntimeException exception1 = new RuntimeException();
+            final Result<Integer> error = anError(exception1);
+            //when
+            final Result<Object> result = error.andThen(v -> () -> {
+                throw new RuntimeException();
+            });
+            //then
+            result.match(
+                    x -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception1));
+        }
+
+        @Test
+        void okayVoid_whenAndThen_whereSuccess_isUpdatedSuccess() {
+            //given
+            final ResultVoid ok = Result.ok();
+            //when
+            final ResultVoid result = ok.andThen(() -> {
+                // do nothing
+            });
+            //then
+            assertThat(result.isOkay()).isTrue();
+        }
+
+        @Test
+        void okayVoid_whenAndThen_whereError_isError() {
+            //given
+            final ResultVoid ok = Result.ok();
+            final RuntimeException exception = new RuntimeException();
+            //when
+            final ResultVoid result = ok.andThen(() -> {
+                throw exception;
+            });
+            //then
+            result.match(
+                    () -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
+        @Test
+        void errorVoid_whereAndThen_whereSuccess_isError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final ResultVoid error = Result.error(exception);
+            //when
+            final ResultVoid result = error.andThen(() -> {
+                // do nothing
+            });
+            //then
+            result.match(
+                    () -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
+        @Test
+        void errorVoid_whenAndThen_whereError_isOriginalError() {
+            //given
+            final RuntimeException exception1 = new RuntimeException();
+            final ResultVoid error = Result.error(exception1);
+            //when
+            final ResultVoid result = error.andThen(() -> {
+                throw new RuntimeException();
+            });
+            //then
+            result.match(
+                    () -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception1));
+        }
     }
 
-    @Test
-    void okay_whenMaybe_whereFails_isOkayNothing() {
-        //given
-        final Result<Integer> okResult = Result.ok(1);
-        //when
-        final Result<Maybe<Integer>> maybeResult = okResult.maybe(value -> value >= 4);
-        //then
-        assertThat(maybeResult.isOkay()).isTrue();
-        maybeResult.match(
-                success -> assertThat(success.toOptional()).isEmpty(),
-                error -> fail("not an error")
-        );
+    @Nested
+    @DisplayName("thenWith")
+    class ThenWithTests {
+        @Test
+        void okay_whenThenWith_whereOkay_isOriginalSuccess() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final Result<Integer> result = ok.thenWith(v -> () -> {
+                // do something with v
+            });
+            //then
+            assertThat(result).isSameAs(ok);
+        }
+
+        @Test
+        void okay_whenThenWith_whereError_thenError() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            final RuntimeException exception = new RuntimeException();
+            //when
+            final Result<Integer> result = ok.thenWith(v -> () -> {
+                throw exception;
+            });
+            //then
+            result.match(
+                    x -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
+        @Test
+        void error_whenThenWith_whereOkay_thenOriginalError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            final Result<Integer> result = error.thenWith(v -> () -> {
+                // do something with v
+            });
+            //then
+            assertThat(result).isSameAs(error);
+        }
+
+        @Test
+        void error_whenThenWith_whenError_thenOriginalError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            final Result<Integer> result = error.thenWith(v -> () -> {
+                throw new RuntimeException();
+            });
+            //then
+            assertThat(result).isSameAs(error);
+        }
+
     }
 
-    @Test
-    void error_whenMaybe_wherePasses_isError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> errorResult = Result.error(exception);
-        //when
-        final Result<Maybe<Integer>> maybeResult = errorResult.maybe(value -> value >= 0);
-        //then
-        assertThat(maybeResult.isError()).isTrue();
-        maybeResult.match(
-                success -> fail("not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
+    @Nested
+    @DisplayName("thenWithV")
+    class ThenWithVTests {
+        @Test
+        void okay_whenThenWithV_whereOkay_isSuccessVoid() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            //when
+            final ResultVoid result = ok.thenWithV(v -> () -> {
+                // do something with v
+            });
+            //then
+            assertThat(result.isOkay()).isTrue();
+        }
+
+        @Test
+        void okay_whenThenWithV_whereError_thenErrorVoid() {
+            //given
+            final Result<Integer> ok = Result.ok(1);
+            final RuntimeException exception = new RuntimeException();
+            //when
+            final ResultVoid result = ok.thenWithV(v -> () -> {
+                throw exception;
+            });
+            //then
+            result.match(
+                    () -> fail("not a success"),
+                    e -> assertThat(e).isSameAs(exception));
+        }
+
+        @Test
+        void error_whenThenWithV_whereOkay_thenErrorVoid() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            final ResultVoid result = error.thenWithV(v -> () -> {
+                // do something with v
+            });
+            //then
+            assertThat(result.isError()).isTrue();
+        }
+
+        @Test
+        void error_whenThenWithV_whenError_thenErrorVoid() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> error = anError(exception);
+            //when
+            final ResultVoid result = error.thenWithV(v -> () -> {
+                throw new RuntimeException();
+            });
+            //then
+            assertThat(result.isError()).isTrue();
+        }
+
     }
 
-    @Test
-    void error_whenMaybe_whereFails_isError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> errorResult = Result.error(exception);
-        //when
-        final Result<Maybe<Integer>> maybeResult = errorResult.maybe(value -> value >= 4);
-        //then
-        assertThat(maybeResult.isError()).isTrue();
-        maybeResult.match(
-                success -> fail("not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
+    @Nested
+    @DisplayName("flatMapMaybe")
+    class FlatMapMaybeTests {
+        @Test
+        void okayJust_whenFlatMapMaybe_whereOkayJust_thenIsOkayJust() {
+            //given
+            final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
+            //when
+            final Result<Maybe<String>> result = Result.flatMapMaybe(okJust, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
+            //then
+            result.match(
+                    success -> assertThat(success.toOptional()).contains("2"),
+                    error -> fail("Not an error")
+            );
+        }
+
+        @Test
+        void okayJust_whenFlatMapMaybe_whereOkayNothing_thenIsOkayNothing() {
+            //given
+            final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
+            //when
+            final Result<Maybe<String>> result = Result.flatMapMaybe(okJust, maybe -> Result.ok(maybe.flatMap(v -> Maybe.nothing())));
+            //then
+            result.match(
+                    success -> assertThat(success.toOptional()).isEmpty(),
+                    error -> fail("Not an error")
+            );
+        }
+
+        @Test
+        void okayJust_whenFlatMapMaybe_whereError_thenIsError() {
+            //given
+            final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
+            final RuntimeException exception = new RuntimeException();
+            //when
+            final Result<Maybe<Integer>> result = Result.flatMapMaybe(okJust, v ->
+                    Result.error(TypeReference.create(), exception));
+            //then
+            result.match(
+                    success -> fail("Not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Test
+        void okayNothing_whenFlatMapMaybe_thenDoNotApply() {
+            //given
+            final Result<Maybe<Integer>> okNothing = Result.ok(Maybe.nothing());
+            //when
+            final Result<Maybe<String>> result = Result.flatMapMaybe(okNothing, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
+            //then
+            result.match(
+                    success -> assertThat(success.toOptional()).isEmpty(),
+                    error -> fail("Not an error")
+            );
+        }
+
+        @Test
+        void error_whenFlatMapMaybe_thenDoNotApply() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Maybe<Integer>> maybeResult = Result.error(TypeReference.create(), exception);
+            //when
+            final Result<Maybe<String>> result = Result.flatMapMaybe(maybeResult, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
+            //then
+            result.match(
+                    success -> fail("Not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
     }
 
-    @Test
-    void just_whenFromMaybe_isOkay() {
-        //given
-        final Maybe<Integer> just = Maybe.just(1);
-        //when
-        final Result<Integer> result = Result.fromMaybe(just, () -> new RuntimeException());
-        //then
-        assertThat(result.isOkay()).isTrue();
-        result.match(
-                success -> assertThat(success).isEqualTo(1),
-                error -> fail("not an error")
-        );
+    @Nested
+    @DisplayName("reduce")
+    class ReduceTests {
+        @Test
+        void okayOkay_whenReduce_thenCombine() {
+            //given
+            final Result<Integer> result1 = Result.ok(1);
+            final Result<Integer> result10 = Result.ok(10);
+            //when
+            final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
+            //then
+            result11.match(
+                    success -> assertThat(success).isEqualTo(11),
+                    error -> fail("Not an error")
+            );
+        }
+
+        @Test
+        void okayError_whenReduce_thenError() {
+            //given
+            final Result<Integer> result1 = Result.ok(1);
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> result10 = anError(exception);
+            //when
+            final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
+            //then
+            result11.match(
+                    success -> fail("Not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Test
+        void errorOkay_whenReduce_thenError() {
+            //given
+            final RuntimeException exception = new RuntimeException();
+            final Result<Integer> result1 = anError(exception);
+            final Result<Integer> result10 = Result.ok(10);
+            //when
+            final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
+            //then
+            result11.match(
+                    success -> fail("Not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Test
+        void errorError_whenReduce_thenError() {
+            //given
+            final RuntimeException exception1 = new RuntimeException();
+            final Result<Integer> result1 = anError(exception1);
+            final RuntimeException exception10 = new RuntimeException();
+            final Result<Integer> result10 = anError(exception10);
+            //when
+            final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
+            //then
+            result11.match(
+                    success -> fail("Not a success"),
+                    error -> assertThat(error).isSameAs(exception1)
+            );
+        }
     }
 
-    @Test
-    void nothing_whenFromMaybe_isError() {
-        //given
-        final Maybe<Object> nothing = Maybe.nothing();
-        final RuntimeException exception = new RuntimeException();
-        //when
-        final Result<Object> result = Result.fromMaybe(nothing, () -> exception);
-        //then
-        assertThat(result.isError()).isTrue();
-        result.match(
-                success -> fail("not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
+    @Nested
+    @DisplayName("applyOver - Result over a set")
+    class ApplyOverTests {
+
+        @Test
+        @DisplayName("Empty List is Okay")
+        void emptyListIsOkay() {
+            //given
+            var stream = Stream.empty();
+            Consumer<Object> doNothingWithoutError = x -> {};
+            //when
+            var result = Result.applyOver(stream, doNothingWithoutError);
+            //then
+            assertThat(result.isOkay()).isTrue();
+        }
+
+        @Test
+        @DisplayName("Single item list with valid result - is valid result")
+        void singleItemValidIsValid() {
+            //given
+            var stream = Stream.of("foo");
+            //when
+            var result = Result.applyOver(stream, String::length, 0, Integer::sum);
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo(3),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        @DisplayName("Two item list consumed without error - is valid result")
+        void twoItemsConsumedIsValid() {
+            //given
+            var acc = new AtomicInteger(0);
+            var stream = Stream.of(1, 2);
+            Consumer<Integer> accumulate = x -> acc.accumulateAndGet(x, Integer::sum);
+            //when
+            var result = Result.applyOver(stream, accumulate);
+            //then
+            result.match(
+                    () -> assertThat(acc).hasValue(3),
+                    e -> fail("should pass")
+            );
+        }
+
+        @Test
+        @DisplayName("Two item list with valid results - is valid result")
+        void twoItemsValidIsValid() {
+            //given
+            var stream = Stream.of("aaa", "bb");
+            //when
+            var result = Result.applyOver(stream, String::length, 0, Integer::sum);
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo(5),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        @DisplayName("Single item list with error is error")
+        void singleItemErrorIsError() {
+            //given
+            var stream = Stream.of("error");
+            var exception = new RuntimeException();
+            //when
+            var result = Result.applyOver(stream, s -> {
+                throw exception;
+            }, 0, Integer::sum);
+            //then
+            result.match(
+                    success -> fail("not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Nested @DisplayName("Two item list with two errors")
+        class TwoErrorsTests {
+
+            Stream<String> stream = Stream.of("ccc", "ddd");
+            List<String> processed = new ArrayList<>();
+            Result<Integer> result = Result.applyOver(stream, s -> {
+                processed.add(s);
+                throw new RuntimeException(s);
+            }, 0, Integer::sum);
+
+            @Test @DisplayName("is first error")
+            void isFirstError() {
+                result.match(
+                        success -> fail("not a success"),
+                        error -> assertThat(error).hasMessage("ccc")
+                );
+            }
+            @Test
+            @DisplayName("processing stopped after first error")
+            void stoppedOnFirstError() {
+                assertThat(processed).contains("ccc");
+            }
+
+            @Test @DisplayName("second item is not consumed")
+            void secondErrorNotConsumed() {
+                assertThat(processed).doesNotContain("ddd");
+            }
+        }
+
+        @Nested @DisplayName("Two item list with okay then error")
+        class TwoItemsOkayThenErrorTests {
+
+            Stream<String> stream = Stream.of("ccccc", "ddd");
+            List<String> processed = new ArrayList<>();
+            Result<Integer> result = Result.applyOver(stream, s -> {
+                processed.add(s);
+                if ("ddd".equals(s)) {
+                    throw new RuntimeException(s);
+                }
+                return s.length();
+            }, 0, Integer::sum);
+
+            @Test @DisplayName("is error")
+            void isError() {
+                result.match(
+                        success -> fail("not a success"),
+                        error -> assertThat(error).hasMessage("ddd")
+                );
+            }
+
+        }
     }
 
-    @Test
-    void okay_whenToMaybe_isJust() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Maybe<Integer> maybe = Result.toMaybe(ok);
-        //then
-        assertThat(maybe.toOptional()).contains(1);
+    @Nested
+    @DisplayName("flatApplyOver")
+    class flatApplyOverTests {
+
+        @Test
+        @DisplayName("Single item list with valid result - is valid result")
+        void singleItemValidIsValid() {
+            //given
+            var stream = Stream.of("foo");
+            Function<String, Result<Integer>> f = s -> Result.ok(s.length());
+            //when
+            var result = Result.flatApplyOver(stream,
+                    f, 0, Integer::sum);
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo(3),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        @DisplayName("Two item list with valid results - is valid result")
+        void twoItemsValidIsValid() {
+            //given
+            var stream = Stream.of("aaa", "bb");
+            Function<String, Result<Integer>> f = s -> Result.ok(s.length());
+            //when
+            var result = Result.flatApplyOver(stream, f, 0, Integer::sum);
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo(5),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        @DisplayName("Single item list with error is error")
+        void singleItemErrorIsError() {
+            //given
+            var stream = Stream.of("error");
+            var exception = new RuntimeException();
+            Function<String, Result<Integer>> f = s -> anError(exception);
+            //when
+            var result = Result.flatApplyOver(stream, f, 0, Integer::sum);
+            //then
+            result.match(
+                    success -> fail("not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Nested @DisplayName("Two item list with two errors")
+        class TwoErrorsTests {
+
+            Stream<String> stream = Stream.of("ccc", "ddd");
+            List<String> processed = new ArrayList<>();
+            Function<String, Result<Integer>> f = s -> Result.of(() -> {
+                processed.add(s);
+                throw new RuntimeException(s);
+            });
+            Result<Integer> result = Result.flatApplyOver(stream, f, 0, Integer::sum);
+
+            @Test
+            @DisplayName("error in result is the first error raised")
+            void isFirstError() {
+                result.match(
+                        success -> fail("not a success"),
+                        error -> assertThat(error).hasMessage("ccc")
+                );
+            }
+            @Test
+            @DisplayName("Processing stopped after first error")
+            void stoppedOnFirstError() {
+                assertThat(processed).contains("ccc");
+            }
+
+            @Test @DisplayName("second item is not consumed")
+            void secondErrorNotConsumed() {
+                assertThat(processed).doesNotContain("ddd");
+            }
+        }
+
+        @Nested @DisplayName("Two item list with okay then error")
+        class TwoItemsOkayTheErrorTests {
+
+            Stream<String> stream = Stream.of("ccccc", "ddd");
+            List<String> processed = new ArrayList<>();
+            Function<String, Result<Integer>> f = s -> Result.of(() -> {
+                processed.add(s);
+                if ("ddd".equals(s)) {
+                    throw new RuntimeException(s);
+                }
+                return s.length();
+            });
+            Result<Integer> result = Result.flatApplyOver(stream, f, 0, Integer::sum);
+
+            @Test @DisplayName("is error")
+            void isError() {
+                result.match(
+                        success -> fail("not a success"),
+                        error -> assertThat(error).hasMessage("ddd")
+                );
+            }
+
+        }
     }
 
-    @Test
-    void error_whenToMaybe_isNothing() {
-        //given
-        final Result<Object> error = Result.error(new RuntimeException());
-        //when
-        final Maybe<Object> maybe = Result.toMaybe(error);
-        //then
-        assertThat(maybe.toOptional()).isEmpty();
+    @Nested
+    @DisplayName("toEither")
+    class ToEitherTests {
+
+        @Test
+        @DisplayName("Success becomes Right")
+        void successIsRight() {
+            //given
+            Result<String> result = Result.ok("success");
+            //when
+            Either<Throwable, String> either = result.toEither();
+            //then
+            either.match(
+                    left -> fail("not a left"),
+                    right -> assertThat(right).isEqualTo("success")
+            );
+        }
+
+        @Test
+        @DisplayName("Error becomes Left")
+        void errorIsLeft() {
+            //given
+            RuntimeException exception = new RuntimeException();
+            Result<Integer> result = anError(exception);
+            //when
+            Either<Throwable, Integer> either = result.toEither();
+            //then
+            either.match(
+                    left -> assumeThat(left).isSameAs(exception),
+                    right -> fail("not a right")
+            );
+        }
     }
 
-    @Test
-    void okay_whenOrElseThrow_isValue() throws Throwable {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Integer value = ok.orElseThrow();
-        //then
-        assertThat(value).isEqualTo(1);
+    @Nested
+    @DisplayName("from(Either)")
+    class FromEitherTests {
+
+        @Test @DisplayName("left is error")
+        void leftIsError() {
+            //given
+            RuntimeException exception = new RuntimeException();
+            Either<Throwable, String> either = Either.left(exception);
+            //when
+            Result<String> result = Result.from(either);
+            //then
+            result.match(
+                    success -> fail("not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
+        @Test @DisplayName("right is success")
+        void rightIsSuccess() {
+            //given
+            Either<Throwable, String> either = Either.right("foo");
+            //when
+            Result<String> result = Result.from(either);
+            //then
+            result.match(
+                    success -> assertThat(success).isEqualTo("foo"),
+                    error -> fail("not an error")
+            );
+        }
+
     }
 
-    @Test
-    void error_whenOrElseThrow_throws() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> error = Result.error(exception);
-        //when
-        assertThatThrownBy(() -> error.orElseThrow())
-                .isInstanceOf(CheckedErrorResultException.class)
-                .hasCause(exception);
+    @Nested
+    @DisplayName("ofVoid")
+    class OfVoidTests {
+
+        @Test
+        @DisplayName("no error is Success")
+        void okayIsSuccess() {
+            //given
+            VoidCallable voidCallable = () -> {
+                //do nothing
+            };
+            //when
+            ResultVoid result = Result.ofVoid(voidCallable);
+            //then
+            result.match(
+                    () -> assertThat(true).isTrue(),
+                    error -> fail("not an error")
+            );
+        }
+
+        @Test
+        @DisplayName("throws exception is an Error")
+        void exceptionIsError() {
+            //given
+            RuntimeException exception = new RuntimeException();
+            VoidCallable voidCallable = () -> {
+                throw exception;
+            };
+            //when
+            ResultVoid result = Result.ofVoid(voidCallable);
+            //then
+            result.match(
+                    () -> fail("not a success"),
+                    error -> assertThat(error).isSameAs(exception)
+            );
+        }
+
     }
 
-    @Test
-    void okay_whenOrElseThrowT_isValue() throws Exception {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Integer value = ok.orElseThrow(Exception.class);
-        //then
-        assumeThat(value).isEqualTo(1);
-    }
+    /**
+     * These include snippets from the Javadocs and are meant to prove that the examples are valid.
+     */
+    @Nested
+    @DisplayName("javadoc documentation")
+    class JavadocTests {
 
-    @Test void errorT_whenOrElseThrowT_throwsT() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Object> error = Result.error(exception);
-        //then
-        assertThatThrownBy(() -> error.orElseThrow(RuntimeException.class)).isSameAs(exception);
-    }
+        @Nested
+        @DisplayName("Result")
+        class ResultJavadocTests {
 
-    @Test
-    void errorR_whenOrElseThrowT_throwsWrappedR() {
-        //given
-        final IOException exception = new IOException();
-        final Result<Object> error = Result.error(exception);
-        //then
-        assertThatThrownBy(() -> error.orElseThrow(RuntimeException.class))
-                .isInstanceOf(UnexpectedErrorResultException.class)
-                .hasCause(exception);
-    }
+            @Nested
+            @DisplayName("Static constructors")
+            class StaticConstructors {
+                @Test
+                @DisplayName("ok")
+                void ok() {
+                    ResultVoid okay = Result.ok();
+                    //
+                    assertThat(okay.isOkay()).isTrue();
+                }
 
-    @Test
-    void okay_whenOrElseThrowUnchecked_isValue() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Integer value = ok.orElseThrowUnchecked();
-        //then
-        assumeThat(value).isEqualTo(1);
-    }
+                @Test
+                @DisplayName("ok(value)")
+                void okValue() {
+                    Result<Integer> okay = Result.ok(1);
+                    //
+                    okay.match(
+                            s -> assertThat(s).isEqualTo(1),
+                            e -> fail("not an err")
+                    );
+                }
 
-    @Test
-    void error_whenOrElseThrowUnchecked_throwsWrapped() {
-        //given
-        final IOException exception = new IOException();
-        final Result<Object> error = Result.error(exception);
-        //then
-        assertThatThrownBy(() -> error.orElseThrowUnchecked())
-                .isInstanceOf(ErrorResultException.class)
-                .hasCause(exception);
-    }
+                @Test
+                @DisplayName("of")
+                void of() {
+                    Result<Integer> okay = Result.of(() -> 1);
+                    Result<Integer> error = Result.of(() -> {
+                        throw new RuntimeException();
+                    });
+                    //
+                    assertSoftly(s -> {
+                        okay.match(
+                                v -> s.assertThat(v).isEqualTo(1),
+                                e -> fail("not an err")
+                        );
+                        error.match(
+                                v -> fail("not a success"),
+                                e -> s.assertThat(e).isInstanceOf(RuntimeException.class)
+                        );
+                    });
+                }
 
-    @Test
-    void justOkay_whenInvert_thenOkayJust() {
-        //given
-        final Maybe<Result<Integer>> justSuccess = Maybe.just(Result.ok(1));
-        //when
-        final Result<Maybe<Integer>> result = Result.swap(justSuccess);
-        //then
-        result.match(
-                success -> assertThat(success.toOptional()).contains(1),
-                error -> fail("Not an error")
-        );
-    }
+                @Test
+                @DisplayName("ofVoid")
+                void ofVoid() {
+                    ResultVoid okay = Result.ofVoid(() -> System.out.println("Hello, World!"));
+                    ResultVoid error = Result.ofVoid(() -> {
+                        throw new Exception();
+                    });
+                    //
+                    assertSoftly(s -> {
+                        s.assertThat(okay.isOkay()).isTrue();
+                        s.assertThat(error.isError()).isTrue();
+                    });
+                }
 
-    @Test
-    void JustError_whenInvert_isError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Maybe<Result<Object>> justError = Maybe.just(Result.error(exception));
-        //when
-        final Result<Maybe<Object>> result = Result.swap(justError);
-        //then
-        result.match(
-                success -> fail("Not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
-    }
+                @Test
+                @DisplayName("error(Throwable)")
+                void errorThrowable() {
+                    ResultVoid error = Result.error(new RuntimeException());
+                    //
+                    assertThat(error.isError()).isTrue();
+                }
 
-    @Test
-    void nothing_whenInvert_thenOkayNothing() {
-        //given
-        final Maybe<Result<Integer>> nothing = Maybe.nothing();
-        //when
-        final Result<Maybe<Integer>> result = Result.swap(nothing);
-        //then
-        result.match(
-                success -> assertThat(success.toOptional()).isEmpty(),
-                error -> fail("Not an error")
-        );
-    }
+                @Test
+                @DisplayName("error(Class, Throwable)")
+                void errorClassThrowable() {
+                    Result<Integer> error = Result.error(TypeReference.create(), new RuntimeException());
+                    //
+                    assertThat(error.isError()).isTrue();
+                }
 
-    @Test
-    void useCase_whenOkay_thenReturnSuccess() {
-        //given
-        final UseCase useCase = UseCase.isOkay();
-        //when
-        final Result<Double> doubleResult = useCase.businessOperation("file a", "file bc");
-        //then
-        doubleResult.match(
-                success -> assertThat(success).isEqualTo(7.5),
-                error -> fail("not an error")
-        );
-    }
+                @Test
+                @DisplayName("from Either")
+                void fromEither() {
+                    Either<Throwable, String> eitherRight = Either.right("Hello, World!");
+                    Either<Throwable, String> eitherLeft = Either.left(new RuntimeException());
+                    Result<String> success = Result.from(eitherRight);
+                    Result<String> error = Result.from(eitherLeft);
+                    //
+                    assertSoftly(s -> {
+                        success.match(
+                                v -> s.assertThat(v).isEqualTo("Hello, World!"),
+                                e -> fail("not an err")
+                        );
+                        error.match(
+                                v -> fail("not a success"),
+                                e -> s.assertThat(e).isInstanceOf(RuntimeException.class)
+                        );
+                    });
+                }
 
-    @Test
-    void useCase_whenFirstReadIsError_thenReturnError() {
-        //given
-        final UseCase useCase = UseCase.firstReadInvalid();
-        //when
-        final Result<Double> doubleResult = useCase.businessOperation("file def", "file ghij");
-        //then
-        doubleResult.match(
-                success -> fail("not okay"),
-                error -> assertThat(error)
-                        .isInstanceOf(RuntimeException.class)
-                        .hasMessage("file def")
-        );
-    }
+                @Test
+                @DisplayName("from Maybe")
+                void fromMaybe() {
+                    Maybe<Integer> maybe = Maybe.maybe(getValue());
+                    Result<Integer> result = Result.from(maybe, () -> new RuntimeException());
+                    //
+                    assertSoftly(s -> {
+                        result.match(
+                                v -> s.assertThat(v).isEqualTo(getValue()),
+                                e -> fail("not an err")
+                        );
+                    });
+                }
 
-    @Test
-    void useCase_whenSecondReadIsError_thenReturnError() {
-        //given
-        final UseCase useCase = UseCase.secondReadInvalid();
-        //when
-        final Result<Double> doubleResult = useCase.businessOperation("file klmno", "file pqrstu");
-        //then
-        assertThat(doubleResult.isOkay()).isFalse();
-        doubleResult.match(
-                success -> fail("not okay"),
-                error -> assertThat(error)
-                        .isInstanceOf(RuntimeException.class)
-                        .hasMessage("file klmno")
-        );
-    }
+            }
 
-    @Test
-    void okay_toString() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final String toString = ok.toString();
-        //then
-        assertThat(toString).contains("Result.Success{value=1}");
-    }
+            @Nested
+            @DisplayName("Static methods")
+            class StaticMethodsTests {
+                @Test
+                @DisplayName("toMaybe")
+                void toMaybe() {
+                    Result<Integer> result = Result.of(() -> getValue());
+                    Maybe<Integer> maybe = Result.toMaybe(result);
+                    //
+                    assertSoftly(s -> {
+                        maybe.match(
+                                j -> s.assertThat(j).isEqualTo(getValue()),
+                                () -> fail("not a nothing")
+                        );
+                    });
+                }
 
-    @Test
-    void error_toString() {
-        //given
-        final Result<Integer> error = Result.error(new RuntimeException("failed"));
-        //when
-        final String toString = error.toString();
-        //then
-        assertThat(toString).contains("Result.Error{error=java.lang.RuntimeException: failed}");
-    }
+                @Test
+                @DisplayName("flatMayMaybe")
+                void flatMapMaybe() {
+                    Result<Maybe<Integer>> result = Result.of(() -> Maybe.maybe(getValue()));
+                    Result<Maybe<Integer>> maybeResult = Result.flatMapMaybe(result,
+                            maybe -> Result.of(() -> maybe.map(v -> v * 2)));
+                    //
+                    assertSoftly(s -> {
+                        maybeResult.match(
+                                m -> m.match(
+                                        v -> s.assertThat(v).isEqualTo(2 * getValue()),
+                                        () -> fail("not a nothing")),
+                                e -> fail("not an err")
+                        );
+                    });
+                }
 
-    @Test
-    void value_whenResultOf_isOkay() {
-        //given
-        final Callable<String> c = () -> "okay";
-        //when
-        final Result<String> result = Result.of(c);
-        //then
-        result.match(
-                success -> assertThat(success).isEqualTo("okay"),
-                error -> fail("not an error")
-        );
-    }
+                @Test
+                @DisplayName("flatApply(Stream, Consumer")
+                void flatApplyOverStreamConsumer() {
+                    List<String> processed = new ArrayList<>();
+                    Consumer<String> consumer = s -> {
+                        if ("dd".equals(s)) {
+                            throw new RuntimeException("Invalid input: " + s);
+                        }
+                        processed.add(s);
+                    };
 
-    @Test
-    void exception_whenResultOf_isError() {
-        //given
-        final Callable<String> c = () -> {
-            throw new IOException();
-        };
-        //when
-        final Result<String> result = Result.of(c);
-        //then
-        result.match(
-                success -> fail("not a success"),
-                error -> assertThat(error).isInstanceOf(IOException.class)
-        );
-    }
+                    Stream<String> okayStream = Stream.of("aa", "bb");
+                    ResultVoid resultOkay = Result.applyOver(okayStream, consumer);
+                    resultOkay.match(
+                            () -> System.out.println("All processed okay."),
+                            error -> System.out.println("Error: " + error.getMessage())
+                    );
+                    System.out.println("Processed: " + processed);
+                    // All processed okay.
+                    // Processed: [aa, bb]
 
-    @Test
-    void okay_whenPeek_isConsumed() {
-        //given
-        final Result<Integer> result = Result.ok(1);
-        final AtomicReference<Integer> consumed = new AtomicReference<>(0);
-        //when
-        final Result<Integer> peeked = result.peek(consumed::set);
-        //then
-        assertThat(consumed).hasValue(1);
-        assertThat(peeked).isSameAs(result);
-    }
+                    processed.add("--");
+                    Stream<String> errorStream = Stream.of("cc", "dd", "ee");// fails at 'dd'
+                    ResultVoid resultError = Result.applyOver(errorStream, consumer);
+                    resultError.match(
+                            () -> System.out.println("All processed okay."),
+                            error -> System.out.println("Error: " + error.getMessage())
+                    );
+                    System.out.println("Processed: " + processed);
+                    // Error: Invalid input: dd
+                    // Processed: [aa, bb, --, cc]
 
-    @Test
-    void error_whenPeek_isNotConsumed() {
-        //given
-        final Result<Integer> result = Result.error(new RuntimeException());
-        final AtomicReference<Integer> consumed = new AtomicReference<>(0);
-        //when
-        final Result<Integer> peeked = result.peek(consumed::set);
-        //then
-        assertThat(consumed).hasValue(0);
-        assertThat(peeked).isSameAs(result);
-    }
+                    assertSoftly(s -> {
+                        s.assertThat(processed).containsExactly(
+                                "aa", "bb", "--",
+                                "cc"
+                        );
+                        resultError.match(
+                                () -> s.fail("not a success"),
+                                e -> s.assertThat(e).isInstanceOf(RuntimeException.class)
+                                        .hasMessage("Invalid input: dd")
+                        );
+                    });
+                }
 
-    @Test
-    void okay_whenOnError_isIgnored() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        ok.onError(e -> fail("not an error"));
-    }
+                @Test
+                @DisplayName("applyOver(Stream, Function, BiFunction")
+                void applyOverStreamFunctionBiFunction() {
+                    Function<String, Integer> f = s -> {
+                        if ("dd".equals(s)) {
+                            throw new RuntimeException("Invalid input: " + s);
+                        }
+                        return s.length();
+                    };
 
-    @Test
-    void error_whenOnError_isConsumed() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> error = Result.error(exception);
-        final AtomicReference<Throwable> capture = new AtomicReference<>();
-        //when
-        error.onError(capture::set);
-        //then
-        assertThat(capture).hasValue(exception);
-    }
+                    assertSoftly(s -> {
 
-    @Test
-    void okay_whenRecover_thenNoChange() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Result<Integer> recovered = ok.recover(e -> Result.ok(2));
-        //then
-        assertThat(recovered).isSameAs(ok);
-    }
+                        Stream<String> okayStream = Stream.of("aa", "bb");
+                        Result<Integer> resultOkay = Result.applyOver(okayStream, f, 0, Integer::sum);
+                        resultOkay.match(
+                                success -> s.assertThat(success).isEqualTo(4),
+                                error -> s.fail("not an err")
+                        );
+                        // Total length: 4
 
-    @Test
-    void error_whenRecover_isSuccess() {
-        //given
-        final Result<Integer> error = Result.error(new RuntimeException());
-        //when
-        final Result<Integer> recovered = error.recover(e -> Result.ok(2));
-        //then
-        recovered.peek(v -> assertThat(v).isEqualTo(2));
-    }
+                        Stream<String> errorStream = Stream.of("cc", "dd");
+                        Result<Integer> resultError = Result.applyOver(errorStream, f, 0, Integer::sum);
+                        resultError.match(
+                                success -> s.fail("not a success"), // will not match
+                                error -> s.assertThat(error.getMessage()).isEqualTo("Invalid input: dd")
+                        );
+                        // Error: Invalid input: dd
 
-    @Test
-    void error_whenRecover_whereError_isUpdatedError() {
-        //given
-        final Result<Integer> error = Result.error(new RuntimeException("original"));
-        //when
-        final Result<Integer> recovered = error.recover(e -> Result.error(new RuntimeException("updated")));
-        //then
-        recovered.onError(e -> assertThat(e).hasMessage("updated"));
-    }
+                    });
+                }
 
-    @Test
-    void okay_whenAndThen_whereSuccess_isUpdatedSuccess() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Result<String> result = ok.andThen(v -> () -> "success");
-        //then
-        assertThat(result.isOkay()).isTrue();
-        result.peek(v -> assertThat(v).isEqualTo("success"));
-    }
+                @Test
+                @DisplayName("flatApplyOver")
+                void flatApplyOver() {
+                    Function<String, Result<Integer>> f = s -> {
+                        if ("dd".equals(s)) {
+                            return Result.error(TypeReference.create(), new RuntimeException("Invalid input: " + s));
+                        }
+                        return Result.ok(s.length());
+                    };
 
-    @Test
-    void okay_whenAndThen_whereError_isError() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        final RuntimeException exception = new RuntimeException();
-        //when
-        final Result<Object> result = ok.andThen(v -> () -> {
-            throw exception;
-        });
-        //then
-        assertThat(result.isError()).isTrue();
-        result.onError(e -> assertThat(e).isSameAs(exception));
-    }
+                    assertSoftly(s -> {
 
-    @Test
-    void error_whereAndThen_whereSuccess_isError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Object> error = Result.error(exception);
-        //when
-        final Result<Object> result = error.andThen(v -> () -> "success");
-        //then
-        assertThat(result.isError()).isTrue();
-        result.onError(e -> assertThat(e).isSameAs(exception));
-    }
+                        Stream<String> okayStream = Stream.of("aa", "bb");
+                        Result<Integer> resultOkay = Result.flatApplyOver(okayStream, f, 0, Integer::sum);
+                        resultOkay.match(
+                                success -> s.assertThat(success).isEqualTo(4),
+                                error -> s.fail("not an err")
+                        );
+                        // Total length: 4
 
-    @Test
-    void error_whenAndThen_whereError_isOriginalError() {
-        //given
-        final RuntimeException exception1 = new RuntimeException();
-        final Result<Object> error = Result.error(exception1);
-        //when
-        final Result<Object> result = error.andThen(v -> () -> {
-            throw new RuntimeException();
-        });
-        //then
-        assertThat(result.isError()).isTrue();
-        result.onError(e -> assertThat(e).isSameAs(exception1));
-    }
+                        Stream<String> errorStream = Stream.of("cc", "dd");
+                        Result<Integer> resultError = Result.flatApplyOver(errorStream, f, 0, Integer::sum);
+                        resultError.match(
+                                success -> s.fail("not a success"), // will not match
+                                error -> s.assertThat(error.getMessage()).isEqualTo("Invalid input: dd")
+                        );
+                        // Error: Invalid input: dd
+                    });
+                }
 
-    @Test
-    void okay_whenThenWith_whereOkay_isOriginalSuccess() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        //when
-        final Result<Integer> result = ok.thenWith(v -> () -> {
-            // do something with v
-        });
-        //then
-        assertThat(result).isSameAs(ok);
-    }
+                @Test
+                @DisplayName("thenWith")
+                void thenWith() {
+                    AtomicInteger capture = new AtomicInteger();
+                    Supplier<Integer> doSomething = () -> 1;
+                    Consumer<Integer> doSomethingElse = capture::set;
+                    //
+                    Result<Integer> r = Result.of(() -> doSomething.get())
+                            .thenWith(value -> () -> doSomethingElse.accept(value));
+                    //
+                    assertThat(capture).hasValue(1);
+                }
+            }
 
-    @Test
-    void okay_whenThenWith_whereError_thenError() {
-        //given
-        final Result<Integer> ok = Result.ok(1);
-        final RuntimeException exception = new RuntimeException();
-        //when
-        final Result<Integer> result = ok.thenWith(v -> () -> {
-            throw exception;
-        });
-        //then
-        assertThat(result.isError()).isTrue();
-        result.onError(e -> assertThat(e).isSameAs(exception));
-    }
+            @Nested
+            @DisplayName("default methods")
+            class DefaultMethodTests {
 
-    @Test
-    void error_whenThenWith_whereOkay_thenOriginalError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> error = Result.error(exception);
-        //when
-        final Result<Integer> result = error.thenWith(v -> () -> {
-            // do something with v
-        });
-        //then
-        assertThat(result).isSameAs(error);
-    }
+                @Test
+                @DisplayName("result")
+                void result() {
+                    Result<Integer> start = Result.ok(1);
+                    Result<Integer> okay = start.result(() -> 1);
+                    Result<Integer> error = start.result(() -> {
+                        throw new RuntimeException();
+                    });
+                    //
+                    assertSoftly(s -> {
+                        okay.match(
+                                v -> s.assertThat(v).isEqualTo(1),
+                                e -> fail("not an err")
+                        );
+                        error.match(
+                                v -> fail("not a success"),
+                                e -> s.assertThat(e).isInstanceOf(RuntimeException.class)
+                        );
+                    });
+                }
 
-    @Test
-    void error_whenThenWith_whenError_thenOriginalError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> error = Result.error(exception);
-        //when
-        final Result<Integer> result = error.thenWith(v -> () -> {
-            throw new RuntimeException();
-        });
-        //then
-        assertThat(result).isSameAs(error);
-    }
+                @Test
+                @DisplayName("toEither")
+                void toEither() {
+                    Result<String> success = Result.ok("success");
+                    RuntimeException exception = new RuntimeException();
+                    Result<String> error = Result.error(TypeReference.create(), exception);
 
-    @Test
-    void okayJust_whenFlatMapMaybe_whereOkayJust_thenIsOkayJust() {
-        //given
-        final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
-        //when
-        final Result<Maybe<String>> result = Result.flatMapMaybe(okJust, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
-        //then
-        result.match(
-                success -> assertThat(success.toOptional()).contains("2"),
-                error -> fail("Not an error")
-        );
-    }
+                    Either<Throwable, String> eitherRight = success.toEither();
+                    Either<Throwable, String> eitherLeft = error.toEither();
+                    //
+                    assertSoftly(s -> {
+                        eitherRight.match(
+                                left -> s.fail("not a left"),
+                                right -> s.assertThat(right).isEqualTo("success")
+                        );
+                        eitherLeft.match(
+                                left -> s.assertThat(left).isSameAs(exception),
+                                right -> s.fail("not a right")
+                        );
+                    });
+                }
 
-    @Test
-    void okayJust_whenFlatMapMaybe_whereOkayNothing_thenIsOkayNothing() {
-        //given
-        final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
-        //when
-        final Result<Maybe<String>> result = Result.flatMapMaybe(okJust, maybe -> Result.ok(maybe.flatMap(v -> Maybe.nothing())));
-        //then
-        result.match(
-                success -> assertThat(success.toOptional()).isEmpty(),
-                error -> fail("Not an error")
-        );
-    }
+            }
 
-    @Test
-    void okayJust_whenFlatMapMaybe_whereError_thenIsError() {
-        //given
-        final Result<Maybe<Integer>> okJust = Result.ok(Maybe.just(1));
-        final RuntimeException exception = new RuntimeException();
-        //when
-        final Result<Maybe<Integer>> result = Result.flatMapMaybe(okJust, v -> Result.error(exception));
-        //then
-        result.match(
-                success -> fail("Not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
-    }
+            @Nested
+            @DisplayName("instance methods")
+            class InstanceMethods {
 
-    @Test
-    void okayNothing_whenFlatMapMaybe_thenDoNotApply() {
-        //given
-        final Result<Maybe<Integer>> okNothing = Result.ok(Maybe.nothing());
-        //when
-        final Result<Maybe<String>> result = Result.flatMapMaybe(okNothing, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
-        //then
-        result.match(
-                success -> assertThat(success.toOptional()).isEmpty(),
-                error -> fail("Not an error")
-        );
-    }
+                @Test
+                @DisplayName("orElse")
+                void orElse() {
+                    assertThatExceptionOfType(CheckedErrorResultException.class)
+                            .isThrownBy(() -> Result.of(() -> getErrorValue()).orElseThrow())
+                            .withCauseInstanceOf(RuntimeException.class);
+                }
 
-    @Test
-    void error_whenFlatMapMaybe_thenDoNotApply() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Maybe<Integer>> maybeResult = Result.error(exception);
-        //when
-        final Result<Maybe<String>> result = Result.flatMapMaybe(maybeResult, maybe -> Result.ok(maybe.flatMap(v -> Maybe.just("2"))));
-        //then
-        result.match(
-                success -> fail("Not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
-    }
+                @Test
+                @DisplayName("toVoid")
+                void toVoid() {
+                    ResultVoid result = Result.of(() -> getResultValue()).toVoid();
+                    //
+                    assertThat(result).isInstanceOf(SuccessVoid.class);
+                }
 
-    @Test
-    void okayOkay_whenReduce_thenCombine() {
-        //given
-        final Result<Integer> result1 = Result.ok(1);
-        final Result<Integer> result10 = Result.ok(10);
-        //when
-        final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
-        //then
-        result11.match(
-                success -> assertThat(success).isEqualTo(11),
-                error -> fail("Not an error")
-        );
-    }
+                @Test
+                @DisplayName("map")
+                void map() {
+                    Result<String> result = Result.of(() -> getValue())
+                            .map(v -> String.valueOf(v));
+                    //
+                    result.match(
+                            success -> assertThat(success).isEqualTo("1"),
+                            error -> fail("not en err")
+                    );
+                }
 
-    @Test
-    void okayError_whenReduce_thenError() {
-        //given
-        final Result<Integer> result1 = Result.ok(1);
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> result10 = Result.error(exception);
-        //when
-        final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
-        //then
-        result11.match(
-                success -> fail("Not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
-    }
+                @Test
+                @DisplayName("isOkay")
+                void isOkay() {
+                    boolean isOkay = Result.of(() -> getValue()).isOkay();
+                    //
+                    assertThat(isOkay).isTrue();
+                }
 
-    @Test
-    void errorOkay_whenReduce_thenError() {
-        //given
-        final RuntimeException exception = new RuntimeException();
-        final Result<Integer> result1 = Result.error(exception);
-        final Result<Integer> result10 = Result.ok(10);
-        //when
-        final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
-        //then
-        result11.match(
-                success -> fail("Not a success"),
-                error -> assertThat(error).isSameAs(exception)
-        );
-    }
+                @Test
+                @DisplayName("isError")
+                void isError() {
+                    boolean isError = Result.of(() -> getValue()).isError();
+                    //
+                    assertThat(isError).isFalse();
+                }
 
-    @Test
-    void errorError_whenReduce_thenError() {
-        //given
-        final RuntimeException exception1 = new RuntimeException();
-        final Result<Integer> result1 = Result.error(exception1);
-        final RuntimeException exception10 = new RuntimeException();
-        final Result<Integer> result10 = Result.error(exception10);
-        //when
-        final Result<Integer> result11 = result1.reduce(result10, (a, b) -> a + b);
-        //then
-        result11.match(
-                success -> fail("Not a success"),
-                error -> assertThat(error).isSameAs(exception1)
-        );
+                @Test
+                @DisplayName("onErrorClassConsumer")
+                void onErrorClassConsumer() {
+                    AtomicReference<UnsupportedOperationException> err = new AtomicReference<>();
+                    Exception exception = new UnsupportedOperationException();
+                    //
+                    Result.of(() -> {
+                                throw exception;
+                            })
+                            .onError(UnsupportedOperationException.class,
+                                    e -> err.set(e));
+                    //
+                    assertThat(err.get()).isSameAs(exception);
+                }
+
+                @Test
+                @DisplayName("onErrorConsumer")
+                void onErrorConsumer() {
+                    AtomicReference<Throwable> err = new AtomicReference<>();
+                    Exception exception = new UnsupportedOperationException();
+                    //
+                    Result.of(() -> {
+                                throw exception;
+                            })
+                            .onError(e -> err.set(e));
+                    //
+                    assertThat(err).hasValue(exception);
+                }
+
+                @Test
+                @DisplayName("orElseThrowUnchecked")
+                void orElseThrowUnchecked() {
+                    Integer result = Result.of(() -> getValue())
+                            .orElseThrowUnchecked();
+                    //
+                    assertThat(result).isEqualTo(1);
+                }
+
+                @Test
+                @DisplayName("orElseThrowClass")
+                void orElseThrowClass() throws IOException {
+                    Integer result = Result.of(() -> getValue())
+                            .orElseThrow(IOException.class);
+                    //
+                    assertThat(result).isEqualTo(1);
+                }
+
+                @Test
+                @DisplayName("peek")
+                void peek() {
+                    AtomicInteger capture = new AtomicInteger();
+                    //
+                    Result<Integer> result = Result.of(() -> getValue())
+                            .peek(v -> capture.set(v));
+                    //
+                    assertThat(capture).hasValue(getValue());
+                }
+
+                @Test
+                @DisplayName("recover")
+                void recover() {
+                    Result<Integer> result = Result.of(() -> getErrorValue())
+                            .recover(e -> Result.of(() -> getSafeValue(e)));
+                    //
+                    result.match(
+                            s -> assertThat(s).isEqualTo(2),
+                            e -> fail("not an error")
+                    );
+                }
+
+                @Test
+                @DisplayName("match")
+                void match() {
+                    AtomicReference<Object> capture = new AtomicReference<>();
+                    //
+                    Result.of(() -> getValue())
+                            .match(
+                                    success -> capture.set(success),
+                                    error -> capture.set(error)
+                            );
+                    //
+                    assertThat(capture).hasValue(getValue());
+                }
+
+                @Test
+                @DisplayName("flatMap")
+                void flatMap() {
+                    Result<String> result =
+                            Result.of(() -> getValue())
+                                    .flatMap(v -> Result.of(() -> String.valueOf(v)));
+                    //
+                    result.match(
+                            s -> assertThat(s).isEqualTo("1"),
+                            e -> fail("not an err")
+                    );
+                }
+
+                @Test
+                @DisplayName("flatMapV")
+                void flatMapV() {
+                    ResultVoid result = Result.of(() -> getValue())
+                            .flatMapV(v -> Result.ok());
+                    //
+                    assertThat(result.isOkay()).isTrue();
+                }
+
+                @Test
+                @DisplayName("onSuccess")
+                void onSuccess() {
+                    AtomicInteger capture = new AtomicInteger();
+                    //
+                    Result.of(() -> getValue())
+                            .onSuccess(v -> capture.set(v));
+                    //
+                    assertThat(capture).hasValue(getValue());
+                }
+
+            }
+
+            private Result<Integer> getResultValue() {
+                return Result.ok(getValue());
+            }
+
+            private Integer getValue() {
+                return 1;
+            }
+
+            private Integer getSafeValue(Throwable e) {
+                return 2;
+            }
+
+            private Integer getErrorValue() {
+                throw new RuntimeException();
+            }
+
+        }
+
+        @Nested
+        @DisplayName("ResultVoid")
+        class ResultVoidJavadocTests {
+
+            @Test
+            @DisplayName("match")
+            void match() {
+                AtomicBoolean success = new AtomicBoolean();
+                AtomicBoolean error = new AtomicBoolean();
+                //
+                Result.ofVoid(() -> doSomethingSafe()) // ResultVoid
+                        .match(
+                                () -> success.set(true), // has no value
+                                e -> error.set(true)
+                        );
+                //
+                assertSoftly(s -> {
+                    s.assertThat(success).isTrue();
+                    s.assertThat(error).isFalse();
+                });
+            }
+
+            @Test
+            @DisplayName("recover")
+            void recover() {
+                ResultVoid result = Result.ofVoid(() -> doSomethingRisky("first"))
+                        .recover(e -> Result.ofVoid(() -> doSomethingRisky("second")));
+                //
+                result.match(
+                        () -> fail("not a success"),
+                        e -> assertThat(e).isInstanceOf(RuntimeException.class)
+                                .extracting("message").isEqualTo("second")
+                );
+            }
+
+            @Test
+            @DisplayName("onSuccess")
+            void onSuccess() {
+                AtomicBoolean capture = new AtomicBoolean();
+                //
+                Result.ofVoid(() -> doSomethingRisky())
+                        .onSuccess(() -> capture.set(true));
+                //
+                assertThat(capture).isFalse();
+            }
+
+            @Test
+            @DisplayName("onErrorClassConsumer")
+            void onErrorClassConsumer() {
+                AtomicReference<UnsupportedOperationException> err = new AtomicReference<>();
+                Exception exception = new UnsupportedOperationException();
+                //
+                Result.ofVoid(() -> {
+                            throw exception;
+                        })
+                        .onError(UnsupportedOperationException.class,
+                                e -> err.set(e));
+                //
+                assertThat(err.get()).isSameAs(exception);
+            }
+
+            @Test
+            @DisplayName("andThen")
+            void andThen() {
+                AtomicBoolean capture = new AtomicBoolean();
+                //
+                Result.ofVoid(() -> doSomethingRisky())
+                        .andThen(() -> capture.set(true));
+                //
+                assertThat(capture).isFalse();
+            }
+
+            @Test
+            @DisplayName("inject")
+            void inject() {
+                Result<Integer> result = Result.ofVoid(() -> doSomethingRisky())
+                        .inject(() -> 1);
+                //
+                result.match(
+                        s -> assertThat(s).isEqualTo(1),
+                        e -> fail("not an err")
+                );
+            }
+
+            private void doSomethingSafe() {
+
+            }
+
+            private void doSomethingRisky() throws RuntimeException {
+                throw new RuntimeException();
+            }
+
+            private void doSomethingRisky(String message) throws RuntimeException {
+                throw new RuntimeException(message);
+            }
+
+        }
     }
 
     @RequiredArgsConstructor
@@ -831,7 +2303,7 @@ class ResultTest implements WithAssertions {
             if (okay) {
                 return Result.ok(fileName.length());
             }
-            return Result.error(new RuntimeException(fileName));
+            return Result.error(TypeReference.create(), new RuntimeException(fileName));
         }
 
         private Result<Integer> adjustValue(final Integer value) {
@@ -843,4 +2315,4 @@ class ResultTest implements WithAssertions {
         }
 
     }
-}
\ No newline at end of file
+}