From 012d1fbc27dc1aa40a1652f034eb52bc624ccad7 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 3 May 2024 23:40:04 +0100
Subject: [PATCH 01/45] Add custom port of Rust's `Result`

Implements all methods present on Rust's `Result` type
that can actually be implemented in Java and in a more Java-esque style.
There were some methods that are impractical / impossible to implement in Java:
- `unchecked_*` for obvious reasons
- `unwrap_or_default`: no static polymorphism - more info in the big comment
- `into_ok`: No infallible/`!` type in Java, not enough stuff at compile time to work (see comment)
- The `impl`s on nested `Result` types, etc. as we can only have 1 class-wide constraint (see comment). Although we could make those `static` methods if we really need them.

Possibly, we could also make an `Option<T>` class for more convenience.
---
 .../marcellperger/mathexpr/util/Result.java   | 334 ++++++++++++++++++
 .../net/marcellperger/mathexpr/util/Util.java |  50 +++
 .../marcellperger/mathexpr/util/VoidVal.java  |  20 ++
 3 files changed, 404 insertions(+)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/Result.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/VoidVal.java

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Result.java b/src/main/java/net/marcellperger/mathexpr/util/Result.java
new file mode 100644
index 0000000..8dd6a7b
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/Result.java
@@ -0,0 +1,334 @@
+package net.marcellperger.mathexpr.util;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+// TODO maybe separate (sub-)package?
+
+
+/**
+ * An implementation of Rust's immutable {@code Result} type that stores either:
+ * <ul><li>A value of type {@link T} representing success</li>
+ * <li>An error value of type {@link E} representing an error</li></ul>
+ * No restrictions are placed on any of these types for convenience and flexibility.
+ * @see <a href=https://doc.rust-lang.org/std/result/enum.Result.html#>Rust's <code>std::result::Result</code></a>
+ * @param <T> Type of the {@link Ok} value
+ * @param <E> Type of the {@link Err} error value
+ */
+@SuppressWarnings({"unused", "InnerClassOfInterface"})  // should be an abstract class but then the `record Ok/Err` cannot extend it
+public sealed interface Result<T, E> extends Iterable<T> {
+    /*
+    impl<T, E> Result<T, E> for Ok<T> { ... }
+
+    impl<T, E> Result<T, E> for Err<E> { ... }
+
+    */
+    record Ok<T, E>(T value) implements Result<T, E> {
+        @Override
+        public Ok<T, E> ok() { return this; }
+
+        public<E2> Ok<T, E2> cast() { return new Ok<>(value); }
+    }
+    // Ok<T, E1> == Ok<T, E2>
+    // void f(Ok<T, E1> arg);
+    //   f(new Ok<T, E2>(...).cast())
+
+    record Err<T, E>(E exc) implements Result<T, E> {
+        public Err<T, E> err() { return this; }
+
+        public<R2> Err<R2, E> cast() { return new Err<>(exc); }
+    }
+
+    default @Nullable Ok<T, E> ok() { return null; }
+    default @Nullable Err<T, E> err() { return null; }
+
+    default Optional<Ok<T, E>> okOpt() { return Optional.ofNullable(ok()); }
+    default Optional<Err<T, E>> errOpt() { return Optional.ofNullable(err()); }
+
+
+    default boolean isOk() { return ok() != null; }
+    default boolean isErr() { return err() != null; }
+
+    default boolean isOkAnd(Predicate<? super T> f) {
+        return switch (this) {
+            case Ok(T value) -> f.test(value);
+            case Err<T, E> e -> false;
+        };
+    }
+    default boolean isErrAnd(Predicate<? super E> f)  {
+        return switch (this) {
+            case Ok<T, E> o -> false;
+            case Err(E err) -> f.test(err);
+        };
+    }
+
+    // TODO: once Option is done, do proper ok() / err() -> Option<T / E>
+
+    default <U> Result<U, E> map(Function<? super T, ? extends U> op) {
+        return switch (this) {
+            case Ok(T value) -> new Ok<>(op.apply(value));
+            case Err<T, E> e -> e.cast();
+        };
+    }
+    // TODO some sort of Consumer<> variant of these or a
+    //  (IMO more logically named) valueOrElse / tryElse / ifLetElse / andThenElse
+    default <U> U mapOr(U default_, Function<? super T, ? extends U> f) {
+        return switch (this) {
+            case Ok(T value) -> f.apply(value);
+            case Err<T, E> _err -> default_;
+        };
+    }
+    default <U> U mapOrElse(Function<? super E, ? extends U> defaultFn, Function<? super T, ? extends U> f) {
+        return switch (this) {
+            case Ok(T value) -> f.apply(value);
+            case Err(E err) -> defaultFn.apply(err);
+        };
+    }
+    default <E2> Result<T, E2> mapErr(Function<? super E, ? extends E2> op) {
+        return switch (this) {
+            case Err(E err) -> new Err<>(op.apply(err));
+            case Ok<T, E> o -> o.cast();
+        };
+    }
+
+    default Result<T, E> inspect(Consumer<? super T> f) {
+        return map(value -> {
+            f.accept(value);
+            return value;
+        });
+    }
+    default Result<T, E> inspectErr(Consumer<? super E> f) {
+        return mapErr(exc -> {
+            f.accept(exc);
+            return exc;
+        });
+    }
+
+    // .iter()-esque methods: why does Java have SO MANY - one is enough.
+    default Stream<T> stream() {
+        return okOpt().map(Ok::value).stream();
+    }
+    // Iterable automatically implements `spliterator()` for us
+    @NotNull
+    @Override
+    default Iterator<T> iterator() {
+        return switch (this) {
+            case Ok(T value) -> Util.singleItemIterator(value);
+            case Err(E _err) -> Collections.emptyIterator();
+        };
+    }
+    @Override
+    default void forEach(Consumer<? super T> action) {
+        map(Util.consumerToFunction(action));
+    }
+
+    default T unwrap() {
+        return expect("unwrap() got Err value");
+    }
+    default T expect(String msg) {
+        return okOpt().orElseThrow(() -> ResultPanicWithValueException.fromMaybeExcValue(err(), msg)).value;
+    }
+    // We CANNOT do unwrap_or_default because Java: <rant>
+    //  - Static methods cannot be overloaded properly and cannot even be part of an interface
+    //     (static methods are very much NOT first-class things in Java - unlike Rust)
+    //      so the language that is the 'standard' Object-Oriented language cannot
+    //      even do polymorphism for static methods! (without resorting to
+    //      runtime non-compile-time-checked reflection)
+    //  - My (very many) attempts to solve it using C++-style CRTP have all failed
+    //     because Java handles generics using type erasure, making 1 general
+    //     type-erased version of a method so any attempts to call methods on the passed subtype
+    //     just results on the method being called on the type declared extended in the `<T extends ...>`.
+    //     Another problematic consequence of (I think) type erasure is that a class hierarchy
+    //     cannot implement the same interface with 2 different types so something
+    //     cannot be both Iterable<String> and Iterable<Long>.
+    //     IMO, handling generics using monomorphisation (like C++ and Rust) would solve these issues and would
+    //     allow much greater flexibility and could open paths to a SFINAE-type
+    //     system which would solve the first BP.
+    //  - I really don't want to use reflection, because in strongly typed languages,
+    //     my philosophy is "Check as much as possible at compile-time to reduce runtime failure". </rant>
+    default E expect_err(String msg) {
+        return errOpt().orElseThrow(() -> ResultPanicWithValueException.fromPlainValue(ok(), msg)).exc;
+    }
+    default E unwrap_err() {
+        return expect_err("unwrap_err() got Ok value");
+    }
+    // We can't implement into_ok/into_err as Java doesn't have that
+    // kind of infallible type and I don't think Java can be that rigorous about
+    // infallibility (Java's type system in proven to be unsound so...)
+    // or can't even reason about it in the first place.
+
+    default <U> Result<U, E> and(Result<U, E> other) {
+        return switch (this) {
+            case Ok<T, E> _ok -> other;  // everything normal, return right
+            case Err<T, E> err -> err.cast();
+        };
+    }
+    default <U> Result<U, E> andThen(Supplier<? extends Result<U, E>> then) {
+        return switch (this) {
+            case Ok<T, E> _ok -> then.get();
+            case Err<T, E> err -> err.cast();
+        };
+    }
+
+    default <E2> Result<T, E2> or(Result<T, E2> other) {
+        return switch (this) {
+            case Ok<T, E> ok -> ok.cast();
+            case Err<T, E> _err -> other;
+        };
+    }
+    default <E2> Result<T, E2> orElse(Supplier<? extends Result<T, E2>> elseFn) {
+        return switch (this) {
+            case Ok<T, E> ok -> ok.cast();
+            case Err<T, E> _err -> elseFn.get();  // `this` failed so try `elseFn` - "You're my only hope"
+        };
+    }
+
+    default T unwrapOr(T defaultV) {
+        return mapOr(defaultV, Function.identity());
+    }
+    default T unwrapOrElse(Function<? super E, ? extends T> ifErr) {
+        return mapOrElse(ifErr, Function.identity());
+    }
+    // no unwrap_unchecked/unwrap_err_unchecked for obvious reasons (usually Java != UB/unsafe)
+
+    // Cannot have implementations for Result<Result<T, E>, E> and similar because Java
+    //  has nothing that allows us to enable methods if certain conditions are met
+    //  and no multiple implementation blocks with possibly-different conditions on the type parameters.
+
+    // TODO maybe these exceptions deserve their own file...
+    class ResultPanicException extends RuntimeException {
+        public ResultPanicException() {
+        }
+        public ResultPanicException(String message) {
+            super(message);
+        }
+        public ResultPanicException(String message, Throwable cause) {
+            super(message, cause);
+        }
+        public ResultPanicException(Throwable cause) {
+            super(cause);
+        }
+
+        @Contract(value = " -> new", pure = true)
+        public static @NotNull Builder builder() {
+            return new Builder();
+        }
+
+        public static class Builder {
+            protected @Nullable String msg;
+            protected @Nullable Throwable cause;
+
+            protected Builder() {
+                msg = null;
+                cause = null;
+            }
+
+            @Contract("_ -> this")
+            public Builder msg(@Nullable String msg) {
+                this.msg = msg;
+                return this;
+            }
+            @Contract("_ -> this")
+            public Builder cause(@Nullable Throwable cause) {
+                this.cause = cause;
+                return this;
+            }
+
+            public ResultPanicException build() {
+                return msg != null
+                    ? cause != null ? new ResultPanicException(msg, cause) : new ResultPanicException(msg)
+                    : cause != null ? new ResultPanicException(cause) : new ResultPanicException();
+            }
+        }
+    }
+
+    // Can't make `Throwable`s generic because java...
+    class ResultPanicWithValueException extends ResultPanicException {
+        protected @Nullable Object value;
+
+        /// To set the cause, use `.builder()`
+        public ResultPanicWithValueException() {
+        }
+
+        public ResultPanicWithValueException(String message) {
+            super(message);
+        }
+
+        public ResultPanicWithValueException(String message, Throwable cause) {
+            super(message, cause);
+        }
+        public ResultPanicWithValueException(String message, Throwable cause, @Nullable Object value) {
+            super(message, cause);
+            this.value = value;
+        }
+
+        public ResultPanicWithValueException(Throwable cause) {
+            super(cause);
+        }
+
+        public static @NotNull ResultPanicWithValueException fromMaybeExcValue(@Nullable Object value, String msg) {
+            return switch (value) {
+                case null -> new ResultPanicWithValueException(msg);
+                case Throwable excValue -> new ResultPanicWithValueException(msg, excValue, excValue);
+                default -> new ResultPanicWithValueException(msg, null, value);
+            };
+        }
+        public static @NotNull ResultPanicWithValueException fromPlainValue(@Nullable Object value, String msg) {
+            ResultPanicWithValueException res = new ResultPanicWithValueException(msg);
+            res.setValue(value);
+            return res;
+        }
+
+        @Override
+        public String getMessage() {
+            return switch (super.getMessage()) {
+                case null -> value != null ? "Panic value: " + value : "";
+                case "" -> value != null ? "Panic value: " + value : "";
+                case String msg -> msg + (value == null ? "" : ": " + value);
+            };
+        }
+
+        protected ResultPanicWithValueException(@NotNull ResultPanicException parent) {
+            this(parent.getMessage(), parent.getCause());
+        }
+
+        public @Nullable Object getValue() {
+            return value;
+        }
+        public void setValue(@Nullable Object value) {
+            this.value = value;
+        }
+
+        public static class Builder extends ResultPanicException.Builder {
+            protected @Nullable Object value;
+
+            public Builder() {
+                super();
+                value = null;
+            }
+
+            @Contract("_ -> this")
+            public Builder value(Object value) {
+                this.value = value;
+                return this;
+            }
+
+            @Override
+            public ResultPanicWithValueException build() {
+                ResultPanicWithValueException ret = new ResultPanicWithValueException(super.build());
+                ret.setValue(value);
+                return ret;
+            }
+        }
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index 14f28cb..bcfa3a4 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -7,6 +7,7 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
@@ -194,4 +195,53 @@ public static<T> T getOnlyItem(@Flow(sourceIsContainer = true) @NotNull Sequence
     public static <K, V> @NotNull V getNotNull(@NotNull Map<K, V> map, K key) {
         return Objects.requireNonNull(map.get(key));
     }
+
+    @Contract(value = "_ -> new", pure = true)
+    public static <T> @NotNull Iterator<T> singleItemIterator(T value) {
+        return new SingleItemIterator<>(value);
+    }
+
+    protected static class SingleItemIterator<T> implements Iterator<T> {
+        T value;
+        boolean isAtEnd;
+
+        public SingleItemIterator(T value) {
+            this.value = value;
+            isAtEnd = false;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return !isAtEnd;
+        }
+
+        @Override
+        public T next() {
+            if(isAtEnd) throw new NoSuchElementException("End of SingleItemIterator reached");
+            return _moveToEndAndPop();
+        }
+
+        protected T _moveToEndAndPop() {
+            isAtEnd = true;
+            T val = value;
+            // Don't hold on to our copy - we don't need it anymore
+            //  as iterators cannot go backwards and this lets JVM free it earlier.
+            value = null;
+            return val;
+        }
+
+        @Override
+        public void forEachRemaining(Consumer<? super T> action) {
+            if(isAtEnd) return;
+            action.accept(_moveToEndAndPop());
+        }
+    }
+
+    @Contract(pure = true)
+    static <T> @NotNull Function<? super T, VoidVal> consumerToFunction(Consumer<T> consumer) {
+        return v -> {
+            consumer.accept(v);
+            return VoidVal.val();
+        };
+    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java b/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java
new file mode 100644
index 0000000..c0db270
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java
@@ -0,0 +1,20 @@
+package net.marcellperger.mathexpr.util;
+
+import org.jetbrains.annotations.NotNull;
+
+
+/** The equivalent of Rust's {@code ()} or Python's {@code NoneType}/{@code None}
+ * or a {@code void} type in Java but can be passed as a type arg
+ * when e.g. you don't actually want to return anything but {@code Function} interface
+ * requires it to return instances of a type. Because 'no value' is a type that has
+ * EXACTLY ONE instance: nothing ({@code None} / {@code ()} / {@code undefined})*/
+@SuppressWarnings("InstantiationOfUtilityClass")  // not a so-called 'utility class'; Pycharm just thinks it is
+public final class VoidVal {
+    static @NotNull VoidVal INST = new VoidVal();
+
+    private VoidVal() {}
+
+    public static VoidVal val() {
+        return INST;
+    }
+}

From 8b670aae73b21d2f019e295a9c20e40315158ae4 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 3 May 2024 23:50:57 +0100
Subject: [PATCH 02/45] Refactor some methods, add more TODOs

---
 .../net/marcellperger/mathexpr/util/Result.java    | 14 +++++---------
 .../java/net/marcellperger/mathexpr/util/Util.java | 10 +++++++++-
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Result.java b/src/main/java/net/marcellperger/mathexpr/util/Result.java
index 8dd6a7b..3470fa6 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Result.java
@@ -101,17 +101,13 @@ default <E2> Result<T, E2> mapErr(Function<? super E, ? extends E2> op) {
         };
     }
 
+    // TODO toString
+
     default Result<T, E> inspect(Consumer<? super T> f) {
-        return map(value -> {
-            f.accept(value);
-            return value;
-        });
+        return map(Util.consumerToIdentityFunc(f));
     }
     default Result<T, E> inspectErr(Consumer<? super E> f) {
-        return mapErr(exc -> {
-            f.accept(exc);
-            return exc;
-        });
+        return mapErr(Util.consumerToIdentityFunc(f));
     }
 
     // .iter()-esque methods: why does Java have SO MANY - one is enough.
@@ -178,7 +174,7 @@ default <U> Result<U, E> andThen(Supplier<? extends Result<U, E>> then) {
             case Ok<T, E> _ok -> then.get();
             case Err<T, E> err -> err.cast();
         };
-    }
+    }  // TODO refactor these add/andThen methods /similar to use common functionality
 
     default <E2> Result<T, E2> or(Result<T, E2> other) {
         return switch (this) {
diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index bcfa3a4..888fa80 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -10,6 +10,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
 
 @SuppressWarnings("unused")
 public class Util {
@@ -238,10 +239,17 @@ public void forEachRemaining(Consumer<? super T> action) {
     }
 
     @Contract(pure = true)
-    static <T> @NotNull Function<? super T, VoidVal> consumerToFunction(Consumer<T> consumer) {
+    static <T> @NotNull Function<? super T, VoidVal> consumerToFunction(Consumer<? super T> consumer) {
         return v -> {
             consumer.accept(v);
             return VoidVal.val();
         };
     }
+    @Contract(pure = true)
+    static <T> @NotNull UnaryOperator<T> consumerToIdentityFunc(Consumer<? super T> consumer) {
+        return v -> {
+            consumer.accept(v);
+            return v;
+        };
+    }
 }

From f9abf206fbc7ce8f260c490433f97f4ae08d1d57 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 4 May 2024 11:09:26 +0100
Subject: [PATCH 03/45] Refactor a bit

---
 .../marcellperger/mathexpr/util/Result.java   | 49 +++++++------------
 1 file changed, 18 insertions(+), 31 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Result.java b/src/main/java/net/marcellperger/mathexpr/util/Result.java
index 3470fa6..b6f868b 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Result.java
@@ -27,30 +27,26 @@
  */
 @SuppressWarnings({"unused", "InnerClassOfInterface"})  // should be an abstract class but then the `record Ok/Err` cannot extend it
 public sealed interface Result<T, E> extends Iterable<T> {
-    /*
-    impl<T, E> Result<T, E> for Ok<T> { ... }
-
-    impl<T, E> Result<T, E> for Err<E> { ... }
-
-    */
     record Ok<T, E>(T value) implements Result<T, E> {
-        @Override
-        public Ok<T, E> ok() { return this; }
-
         public<E2> Ok<T, E2> cast() { return new Ok<>(value); }
     }
-    // Ok<T, E1> == Ok<T, E2>
-    // void f(Ok<T, E1> arg);
-    //   f(new Ok<T, E2>(...).cast())
 
     record Err<T, E>(E exc) implements Result<T, E> {
-        public Err<T, E> err() { return this; }
-
         public<R2> Err<R2, E> cast() { return new Err<>(exc); }
     }
 
-    default @Nullable Ok<T, E> ok() { return null; }
-    default @Nullable Err<T, E> err() { return null; }
+    default @Nullable Ok<T, E> ok() {
+        return switch (this) {
+            case Ok<T, E> ok -> ok;
+            case Err<T, E> _e -> null;
+        };
+    }
+    default @Nullable Err<T, E> err() {
+        return switch (this) {
+            case Ok<T, E> _ok -> null;
+            case Err<T, E> err -> err;
+        };
+    }
 
     default Optional<Ok<T, E>> okOpt() { return Optional.ofNullable(ok()); }
     default Optional<Err<T, E>> errOpt() { return Optional.ofNullable(err()); }
@@ -83,10 +79,7 @@ default <U> Result<U, E> map(Function<? super T, ? extends U> op) {
     // TODO some sort of Consumer<> variant of these or a
     //  (IMO more logically named) valueOrElse / tryElse / ifLetElse / andThenElse
     default <U> U mapOr(U default_, Function<? super T, ? extends U> f) {
-        return switch (this) {
-            case Ok(T value) -> f.apply(value);
-            case Err<T, E> _err -> default_;
-        };
+        return mapOrElse((_e) -> default_, f);
     }
     default <U> U mapOrElse(Function<? super E, ? extends U> defaultFn, Function<? super T, ? extends U> f) {
         return switch (this) {
@@ -96,8 +89,8 @@ default <U> U mapOrElse(Function<? super E, ? extends U> defaultFn, Function<? s
     }
     default <E2> Result<T, E2> mapErr(Function<? super E, ? extends E2> op) {
         return switch (this) {
-            case Err(E err) -> new Err<>(op.apply(err));
             case Ok<T, E> o -> o.cast();
+            case Err(E err) -> new Err<>(op.apply(err));
         };
     }
 
@@ -164,23 +157,17 @@ default E unwrap_err() {
     // or can't even reason about it in the first place.
 
     default <U> Result<U, E> and(Result<U, E> other) {
-        return switch (this) {
-            case Ok<T, E> _ok -> other;  // everything normal, return right
-            case Err<T, E> err -> err.cast();
-        };
+        return andThen(() -> other);
     }
     default <U> Result<U, E> andThen(Supplier<? extends Result<U, E>> then) {
         return switch (this) {
-            case Ok<T, E> _ok -> then.get();
+            case Ok<T, E> _ok -> then.get();  // everything normal with `this`, do next
             case Err<T, E> err -> err.cast();
         };
-    }  // TODO refactor these add/andThen methods /similar to use common functionality
+    }
 
     default <E2> Result<T, E2> or(Result<T, E2> other) {
-        return switch (this) {
-            case Ok<T, E> ok -> ok.cast();
-            case Err<T, E> _err -> other;
-        };
+        return orElse(() -> other);
     }
     default <E2> Result<T, E2> orElse(Supplier<? extends Result<T, E2>> elseFn) {
         return switch (this) {

From a33fdfaa6db0ab40b95a8b3fb18c806a7d0cf1ba Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 4 May 2024 13:36:02 +0100
Subject: [PATCH 04/45] Add more util methods for Result (ifThenElse, toString)

---
 .../marcellperger/mathexpr/util/Result.java   | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Result.java b/src/main/java/net/marcellperger/mathexpr/util/Result.java
index b6f868b..ed0ad22 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Result.java
@@ -27,14 +27,26 @@
  */
 @SuppressWarnings({"unused", "InnerClassOfInterface"})  // should be an abstract class but then the `record Ok/Err` cannot extend it
 public sealed interface Result<T, E> extends Iterable<T> {
+    // hashCode / equals is automatically implemented for these record types, but we customize toString
     record Ok<T, E>(T value) implements Result<T, E> {
         public<E2> Ok<T, E2> cast() { return new Ok<>(value); }
+
+        @Override
+        public String toString() {
+            return "Ok(" + value + ')';
+        }
     }
 
     record Err<T, E>(E exc) implements Result<T, E> {
         public<R2> Err<R2, E> cast() { return new Err<>(exc); }
+
+        @Override
+        public String toString() {
+            return "Err("  + exc + ')';
+        }
     }
 
+
     default @Nullable Ok<T, E> ok() {
         return switch (this) {
             case Ok<T, E> ok -> ok;
@@ -76,8 +88,6 @@ default <U> Result<U, E> map(Function<? super T, ? extends U> op) {
             case Err<T, E> e -> e.cast();
         };
     }
-    // TODO some sort of Consumer<> variant of these or a
-    //  (IMO more logically named) valueOrElse / tryElse / ifLetElse / andThenElse
     default <U> U mapOr(U default_, Function<? super T, ? extends U> f) {
         return mapOrElse((_e) -> default_, f);
     }
@@ -94,7 +104,13 @@ default <E2> Result<T, E2> mapErr(Function<? super E, ? extends E2> op) {
         };
     }
 
-    // TODO toString
+    // not a Rust function. Similar to mapOrElse but reversed arguments
+    default void ifThenElse(Consumer<? super T> okFn, Consumer<? super E> errFn) {
+        mapOrElse(Util.consumerToFunction(errFn), Util.consumerToFunction(okFn));
+    }
+    default <U> U ifThenElse(Function<? super T, ? extends U> okFn, Function<? super E, ? extends U> errFn) {
+        return mapOrElse(errFn, okFn);
+    }
 
     default Result<T, E> inspect(Consumer<? super T> f) {
         return map(Util.consumerToIdentityFunc(f));

From 2af76a838aeadc50a3564c6827754d736bc21ced Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:02:16 +0100
Subject: [PATCH 05/45] Add Result.newOk, Result.newErr

---
 src/main/java/net/marcellperger/mathexpr/util/Result.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Result.java b/src/main/java/net/marcellperger/mathexpr/util/Result.java
index ed0ad22..d4a647a 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Result.java
@@ -46,6 +46,13 @@ public String toString() {
         }
     }
 
+    static <T, E> Ok<T, E> newOk(T value) {
+        return new Ok<>(value);
+    }
+    static <T, E> Err<T, E> newErr(E err) {
+        return new Err<>(err);
+    }
+
 
     default @Nullable Ok<T, E> ok() {
         return switch (this) {

From 77c70762fd9757b9d5a78c1376642366eac1e59d Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:06:13 +0100
Subject: [PATCH 06/45] fix: Add missed `public` to some `Util` methods

---
 src/main/java/net/marcellperger/mathexpr/util/Util.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index 888fa80..cae5ab3 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -239,14 +239,14 @@ public void forEachRemaining(Consumer<? super T> action) {
     }
 
     @Contract(pure = true)
-    static <T> @NotNull Function<? super T, VoidVal> consumerToFunction(Consumer<? super T> consumer) {
+    public static <T> @NotNull Function<? super T, VoidVal> consumerToFunction(Consumer<? super T> consumer) {
         return v -> {
             consumer.accept(v);
             return VoidVal.val();
         };
     }
     @Contract(pure = true)
-    static <T> @NotNull UnaryOperator<T> consumerToIdentityFunc(Consumer<? super T> consumer) {
+    public static <T> @NotNull UnaryOperator<T> consumerToIdentityFunc(Consumer<? super T> consumer) {
         return v -> {
             consumer.accept(v);
             return v;

From 33482580d2a44ff4a1ea50a30cd4b064dd145638 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:15:29 +0100
Subject: [PATCH 07/45] refactor: Move Result into `<...>.util.rs` package

---
 .../mathexpr/util/rs/PanicException.java      |  18 +++
 .../mathexpr/util/{ => rs}/Result.java        | 133 +-----------------
 .../util/rs/ResultPanicException.java         |  55 ++++++++
 .../rs/ResultPanicWithValueException.java     |  87 ++++++++++++
 4 files changed, 162 insertions(+), 131 deletions(-)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
 rename src/main/java/net/marcellperger/mathexpr/util/{ => rs}/Result.java (65%)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
new file mode 100644
index 0000000..fc41512
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
@@ -0,0 +1,18 @@
+package net.marcellperger.mathexpr.util.rs;
+
+public class PanicException extends RuntimeException {
+    public PanicException() {
+    }
+
+    public PanicException(String message) {
+        super(message);
+    }
+
+    public PanicException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public PanicException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/util/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
similarity index 65%
rename from src/main/java/net/marcellperger/mathexpr/util/Result.java
rename to src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index d4a647a..4333434 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -1,6 +1,6 @@
-package net.marcellperger.mathexpr.util;
+package net.marcellperger.mathexpr.util.rs;
 
-import org.jetbrains.annotations.Contract;
+import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -13,8 +13,6 @@
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
-// TODO maybe separate (sub-)package?
-
 
 /**
  * An implementation of Rust's immutable {@code Result} type that stores either:
@@ -210,131 +208,4 @@ default T unwrapOrElse(Function<? super E, ? extends T> ifErr) {
     // Cannot have implementations for Result<Result<T, E>, E> and similar because Java
     //  has nothing that allows us to enable methods if certain conditions are met
     //  and no multiple implementation blocks with possibly-different conditions on the type parameters.
-
-    // TODO maybe these exceptions deserve their own file...
-    class ResultPanicException extends RuntimeException {
-        public ResultPanicException() {
-        }
-        public ResultPanicException(String message) {
-            super(message);
-        }
-        public ResultPanicException(String message, Throwable cause) {
-            super(message, cause);
-        }
-        public ResultPanicException(Throwable cause) {
-            super(cause);
-        }
-
-        @Contract(value = " -> new", pure = true)
-        public static @NotNull Builder builder() {
-            return new Builder();
-        }
-
-        public static class Builder {
-            protected @Nullable String msg;
-            protected @Nullable Throwable cause;
-
-            protected Builder() {
-                msg = null;
-                cause = null;
-            }
-
-            @Contract("_ -> this")
-            public Builder msg(@Nullable String msg) {
-                this.msg = msg;
-                return this;
-            }
-            @Contract("_ -> this")
-            public Builder cause(@Nullable Throwable cause) {
-                this.cause = cause;
-                return this;
-            }
-
-            public ResultPanicException build() {
-                return msg != null
-                    ? cause != null ? new ResultPanicException(msg, cause) : new ResultPanicException(msg)
-                    : cause != null ? new ResultPanicException(cause) : new ResultPanicException();
-            }
-        }
-    }
-
-    // Can't make `Throwable`s generic because java...
-    class ResultPanicWithValueException extends ResultPanicException {
-        protected @Nullable Object value;
-
-        /// To set the cause, use `.builder()`
-        public ResultPanicWithValueException() {
-        }
-
-        public ResultPanicWithValueException(String message) {
-            super(message);
-        }
-
-        public ResultPanicWithValueException(String message, Throwable cause) {
-            super(message, cause);
-        }
-        public ResultPanicWithValueException(String message, Throwable cause, @Nullable Object value) {
-            super(message, cause);
-            this.value = value;
-        }
-
-        public ResultPanicWithValueException(Throwable cause) {
-            super(cause);
-        }
-
-        public static @NotNull ResultPanicWithValueException fromMaybeExcValue(@Nullable Object value, String msg) {
-            return switch (value) {
-                case null -> new ResultPanicWithValueException(msg);
-                case Throwable excValue -> new ResultPanicWithValueException(msg, excValue, excValue);
-                default -> new ResultPanicWithValueException(msg, null, value);
-            };
-        }
-        public static @NotNull ResultPanicWithValueException fromPlainValue(@Nullable Object value, String msg) {
-            ResultPanicWithValueException res = new ResultPanicWithValueException(msg);
-            res.setValue(value);
-            return res;
-        }
-
-        @Override
-        public String getMessage() {
-            return switch (super.getMessage()) {
-                case null -> value != null ? "Panic value: " + value : "";
-                case "" -> value != null ? "Panic value: " + value : "";
-                case String msg -> msg + (value == null ? "" : ": " + value);
-            };
-        }
-
-        protected ResultPanicWithValueException(@NotNull ResultPanicException parent) {
-            this(parent.getMessage(), parent.getCause());
-        }
-
-        public @Nullable Object getValue() {
-            return value;
-        }
-        public void setValue(@Nullable Object value) {
-            this.value = value;
-        }
-
-        public static class Builder extends ResultPanicException.Builder {
-            protected @Nullable Object value;
-
-            public Builder() {
-                super();
-                value = null;
-            }
-
-            @Contract("_ -> this")
-            public Builder value(Object value) {
-                this.value = value;
-                return this;
-            }
-
-            @Override
-            public ResultPanicWithValueException build() {
-                ResultPanicWithValueException ret = new ResultPanicWithValueException(super.build());
-                ret.setValue(value);
-                return ret;
-            }
-        }
-    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
new file mode 100644
index 0000000..c866a1d
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
@@ -0,0 +1,55 @@
+package net.marcellperger.mathexpr.util.rs;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class ResultPanicException extends RuntimeException {
+    public ResultPanicException() {
+    }
+
+    public ResultPanicException(String message) {
+        super(message);
+    }
+
+    public ResultPanicException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ResultPanicException(Throwable cause) {
+        super(cause);
+    }
+
+    @Contract(value = " -> new", pure = true)
+    public static @NotNull Builder builder() {
+        return new Builder();
+    }
+
+    public static class Builder {
+        protected @Nullable String msg;
+        protected @Nullable Throwable cause;
+
+        protected Builder() {
+            msg = null;
+            cause = null;
+        }
+
+        @Contract("_ -> this")
+        public Builder msg(@Nullable String msg) {
+            this.msg = msg;
+            return this;
+        }
+
+        @Contract("_ -> this")
+        public Builder cause(@Nullable Throwable cause) {
+            this.cause = cause;
+            return this;
+        }
+
+        public ResultPanicException build() {
+            return msg != null
+                ? cause != null ? new ResultPanicException(msg, cause) : new ResultPanicException(msg)
+                : cause != null ? new ResultPanicException(cause) : new ResultPanicException();
+        }
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
new file mode 100644
index 0000000..32e31f2
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
@@ -0,0 +1,87 @@
+package net.marcellperger.mathexpr.util.rs;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+// Can't make `Throwable`s generic because java...
+public class ResultPanicWithValueException extends ResultPanicException {
+    protected @Nullable Object value;
+
+    /// To set the cause, use `.builder()`
+    public ResultPanicWithValueException() {
+    }
+
+    public ResultPanicWithValueException(String message) {
+        super(message);
+    }
+
+    public ResultPanicWithValueException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ResultPanicWithValueException(String message, Throwable cause, @Nullable Object value) {
+        super(message, cause);
+        this.value = value;
+    }
+
+    public ResultPanicWithValueException(Throwable cause) {
+        super(cause);
+    }
+
+    protected ResultPanicWithValueException(@NotNull ResultPanicException parent) {
+        this(parent.getMessage(), parent.getCause());
+    }
+
+    public static @NotNull ResultPanicWithValueException fromMaybeExcValue(@Nullable Object value, String msg) {
+        return switch (value) {
+            case null -> new ResultPanicWithValueException(msg);
+            case Throwable excValue -> new ResultPanicWithValueException(msg, excValue, excValue);
+            default -> new ResultPanicWithValueException(msg, null, value);
+        };
+    }
+
+    public static @NotNull ResultPanicWithValueException fromPlainValue(@Nullable Object value, String msg) {
+        ResultPanicWithValueException res = new ResultPanicWithValueException(msg);
+        res.setValue(value);
+        return res;
+    }
+
+    @Override
+    public String getMessage() {
+        return switch (super.getMessage()) {
+            case null -> value != null ? "Panic value: " + value : "";
+            case "" -> value != null ? "Panic value: " + value : "";
+            case String msg -> msg + (value == null ? "" : ": " + value);
+        };
+    }
+
+    public @Nullable Object getValue() {
+        return value;
+    }
+    public void setValue(@Nullable Object value) {
+        this.value = value;
+    }
+
+    public static class Builder extends ResultPanicException.Builder {
+        protected @Nullable Object value;
+
+        public Builder() {
+            super();
+            value = null;
+        }
+
+        @Contract("_ -> this")
+        public Builder value(Object value) {
+            this.value = value;
+            return this;
+        }
+
+        @Override
+        public ResultPanicWithValueException build() {
+            ResultPanicWithValueException ret = new ResultPanicWithValueException(super.build());
+            ret.setValue(value);
+            return ret;
+        }
+    }
+}

From ebf35e13ef5da6b529745c56214aefc307b78de0 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:27:32 +0100
Subject: [PATCH 08/45] test: Start adding tests for Result

---
 .../mathexpr/util/rs/ResultTest.java          | 118 ++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
new file mode 100644
index 0000000..2d829a1
--- /dev/null
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -0,0 +1,118 @@
+package net.marcellperger.mathexpr.util.rs;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ResultTest {
+    Result<Integer, String> getOk() {
+        return Result.newOk(314);
+    }
+    Result<Integer, String> getErr() {
+        return Result.newErr("TESTING_ERROR");
+    }
+
+    @Test
+    void isOk() {
+        assertTrue(getOk().isOk());
+        assertFalse(getErr().isOk());
+    }
+
+    @Test
+    void isErr() {
+        assertFalse(getOk().isErr());
+        assertTrue(getErr().isErr());
+    }
+
+    @Test
+    void isOkAnd() {
+    }
+
+    @Test
+    void isErrAnd() {
+    }
+
+    @Test
+    void map() {
+    }
+
+    @Test
+    void mapOr() {
+    }
+
+    @Test
+    void mapOrElse() {
+    }
+
+    @Test
+    void mapErr() {
+    }
+
+    @Test
+    void ifThenElse() {
+    }
+
+    @Test
+    void testIfThenElse() {
+    }
+
+    @Test
+    void inspect() {
+    }
+
+    @Test
+    void inspectErr() {
+    }
+
+    @Test
+    void stream() {
+    }
+
+    @Test
+    void iterator() {
+    }
+
+    @Test
+    void forEach() {
+    }
+
+    @Test
+    void unwrap() {
+    }
+
+    @Test
+    void expect() {
+    }
+
+    @Test
+    void expect_err() {
+    }
+
+    @Test
+    void unwrap_err() {
+    }
+
+    @Test
+    void and() {
+    }
+
+    @Test
+    void andThen() {
+    }
+
+    @Test
+    void or() {
+    }
+
+    @Test
+    void orElse() {
+    }
+
+    @Test
+    void unwrapOr() {
+    }
+
+    @Test
+    void unwrapOrElse() {
+    }
+}
\ No newline at end of file

From a30248c3face598c66e4cdfc55b643ad75439661 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:47:46 +0100
Subject: [PATCH 09/45] fix: Fix some IntelliJ warnings

---
 .idea/inspectionProfiles/Project_Default.xml                  | 4 ++++
 src/main/java/net/marcellperger/mathexpr/parser/Parser.java   | 3 +--
 .../net/marcellperger/mathexpr/util/rs/PanicException.java    | 1 +
 .../marcellperger/mathexpr/util/rs/ResultPanicException.java  | 1 +
 4 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index e01daa3..69f1877 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -2,5 +2,9 @@
   <profile version="1.0">
     <option name="myName" value="Project Default" />
     <inspection_tool class="SuspiciousLiteralUnderscore" enabled="true" level="WEAK WARNING" enabled_by_default="true" editorAttributes="INFO_ATTRIBUTES" />
+    <inspection_tool class="UnusedReturnValue" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="IGNORE_BUILDER_PATTERN" value="true" />
+      <option name="highestModifier" value="package-private" />
+    </inspection_tool>
   </profile>
 </component>
\ No newline at end of file
diff --git a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
index 2c13958..867c849 100644
--- a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
+++ b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
@@ -152,8 +152,7 @@ boolean advanceIf(@NotNull Function<Character, Boolean> predicate) {
      * @param predicate Keep advancing while this returns true
      * @return Amount of spaces advanced
      */
-    @SuppressWarnings("UnusedReturnValue")
-    int advanceWhile(@NotNull Function<Character, Boolean> predicate) {
+    protected int advanceWhile(@NotNull Function<Character, Boolean> predicate) {
         int n = 0;
         while (notEof() && advanceIf(predicate)) ++n;
         return n;
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
index fc41512..6f7f7c2 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
@@ -1,5 +1,6 @@
 package net.marcellperger.mathexpr.util.rs;
 
+@SuppressWarnings("unused")  // I don't care, this is a **util** package, I'll use it later
 public class PanicException extends RuntimeException {
     public PanicException() {
     }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
index c866a1d..54f0390 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
@@ -47,6 +47,7 @@ public Builder cause(@Nullable Throwable cause) {
         }
 
         public ResultPanicException build() {
+            // This complication is required to ensure that initCause can be set later if not set now.
             return msg != null
                 ? cause != null ? new ResultPanicException(msg, cause) : new ResultPanicException(msg)
                 : cause != null ? new ResultPanicException(cause) : new ResultPanicException();

From 48793a4edab0f37251e5ad9df172fb67f52320a4 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:50:46 +0100
Subject: [PATCH 10/45] fix: Fix more IntelliJ warnings

---
 .idea/inspectionProfiles/Project_Default.xml         | 12 ++++++++++++
 .../net/marcellperger/mathexpr/parser/Parser.java    |  1 +
 .../mathexpr/util/rs/ResultPanicException.java       |  3 ++-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 69f1877..e4125d4 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -6,5 +6,17 @@
       <option name="IGNORE_BUILDER_PATTERN" value="true" />
       <option name="highestModifier" value="package-private" />
     </inspection_tool>
+    <inspection_tool class="unused" enabled="true" level="WARNING" enabled_by_default="true" ignoreAccessors="true" checkParameterExcludingHierarchy="false">
+      <option name="LOCAL_VARIABLE" value="true" />
+      <option name="FIELD" value="true" />
+      <option name="METHOD" value="true" />
+      <option name="CLASS" value="true" />
+      <option name="PARAMETER" value="true" />
+      <option name="REPORT_PARAMETER_FOR_PUBLIC_METHODS" value="true" />
+      <option name="ADD_MAINS_TO_ENTRIES" value="true" />
+      <option name="ADD_APPLET_TO_ENTRIES" value="true" />
+      <option name="ADD_SERVLET_TO_ENTRIES" value="true" />
+      <option name="ADD_NONJAVA_TO_ENTRIES" value="true" />
+    </inspection_tool>
   </profile>
 </component>
\ No newline at end of file
diff --git a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
index 867c849..8a77708 100644
--- a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
+++ b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
@@ -39,6 +39,7 @@ public MathSymbol parseExpr() throws ExprParseException {
 
     // https://regex101.com/r/2EogTA/1
     protected static final Pattern DOUBLE_RE = Pattern.compile("^([+-]?)(\\d*\\.\\d+|\\d+\\.?)(?:[eE]([+-]?\\d+))?");
+    @SuppressWarnings("unused")  // ignore for now - will fix later with the better error handling
     public @NotNull MathSymbol parseDoubleLiteral_exc() throws ExprParseException {
         return switch (parseDoubleLiteral_null()) {
             case null -> throw new ExprParseException("Couldn't parse double in expression");
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
index 54f0390..8df8b6d 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
@@ -20,12 +20,13 @@ public ResultPanicException(Throwable cause) {
         super(cause);
     }
 
+    @SuppressWarnings("unused")  // may be used later
     @Contract(value = " -> new", pure = true)
     public static @NotNull Builder builder() {
         return new Builder();
     }
 
-    public static class Builder {
+    public static class Builder {  // TODO perhaps move up to PanicException class
         protected @Nullable String msg;
         protected @Nullable Throwable cause;
 

From 7a408ad1cac424c947b02a801ffee829e038056c Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 18:51:23 +0100
Subject: [PATCH 11/45] refactor: Refactor ResultPanicWithValueException

---
 .../rs/ResultPanicWithValueException.java     | 28 ++++++++++++++-----
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
index 32e31f2..af9a52b 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
@@ -9,6 +9,7 @@ public class ResultPanicWithValueException extends ResultPanicException {
     protected @Nullable Object value;
 
     /// To set the cause, use `.builder()`
+    @SuppressWarnings("unused")
     public ResultPanicWithValueException() {
     }
 
@@ -25,6 +26,7 @@ public ResultPanicWithValueException(String message, Throwable cause, @Nullable
         this.value = value;
     }
 
+    @SuppressWarnings("unused")
     public ResultPanicWithValueException(Throwable cause) {
         super(cause);
     }
@@ -42,9 +44,7 @@ protected ResultPanicWithValueException(@NotNull ResultPanicException parent) {
     }
 
     public static @NotNull ResultPanicWithValueException fromPlainValue(@Nullable Object value, String msg) {
-        ResultPanicWithValueException res = new ResultPanicWithValueException(msg);
-        res.setValue(value);
-        return res;
+        return new Builder().msg(msg).value(value).build();
     }
 
     @Override
@@ -64,23 +64,37 @@ public void setValue(@Nullable Object value) {
     }
 
     public static class Builder extends ResultPanicException.Builder {
-        protected @Nullable Object value;
+        protected @Nullable Object m_value;
 
         public Builder() {
             super();
-            value = null;
+            m_value = null;
+        }
+
+        @Override
+        public Builder msg(@Nullable String msg) {
+            // I wish there was a better way (e.g. a Self) type - could actually do
+            // CRTP here but that could get messy for users of the base type
+            super.msg(msg);
+            return this;
+        }
+
+        @Override
+        public Builder cause(@Nullable Throwable cause) {
+            super.cause(cause);
+            return this;
         }
 
         @Contract("_ -> this")
         public Builder value(Object value) {
-            this.value = value;
+            this.m_value = value;
             return this;
         }
 
         @Override
         public ResultPanicWithValueException build() {
             ResultPanicWithValueException ret = new ResultPanicWithValueException(super.build());
-            ret.setValue(value);
+            ret.setValue(m_value);
             return ret;
         }
     }

From 84d05dc817a87d162294984d2aa0113a28bbb6dc Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 19:07:34 +0100
Subject: [PATCH 12/45] refactor: Move base Builder up to PanicException

---
 .../mathexpr/util/rs/PanicException.java      | 49 ++++++++++++++++++-
 .../util/rs/ResultPanicException.java         | 32 ++----------
 .../rs/ResultPanicWithValueException.java     | 10 ++--
 3 files changed, 56 insertions(+), 35 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
index 6f7f7c2..e42439a 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/PanicException.java
@@ -1,6 +1,13 @@
 package net.marcellperger.mathexpr.util.rs;
 
-@SuppressWarnings("unused")  // I don't care, this is a **util** package, I'll use it later
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
 public class PanicException extends RuntimeException {
     public PanicException() {
     }
@@ -16,4 +23,44 @@ public PanicException(String message, Throwable cause) {
     public PanicException(Throwable cause) {
         super(cause);
     }
+
+    @SuppressWarnings("unused")  // may be used later
+    @Contract(value = " -> new", pure = true)
+    public static @NotNull Builder builder() {
+        return new Builder();
+    }
+
+    public static class Builder {
+        protected @Nullable String msg;
+        protected @Nullable Throwable cause;
+
+        protected Builder() {
+            msg = null;
+            cause = null;
+        }
+
+        @Contract("_ -> this")
+        public Builder msg(@Nullable String msg) {
+            this.msg = msg;
+            return this;
+        }
+
+        @Contract("_ -> this")
+        public Builder cause(@Nullable Throwable cause) {
+            this.cause = cause;
+            return this;
+        }
+
+        public PanicException build() {
+            return build(PanicException::new, PanicException::new, PanicException::new, PanicException::new);
+        }
+
+        public <T extends PanicException> T build(Supplier<T> ctor0, Function<String, T> ctor1str,
+                                                  Function<? super Throwable, T> ctor1exc,
+                                                  BiFunction<String, ? super Throwable, T> ctor2) {
+            return msg != null
+                ? cause != null ? ctor2.apply(msg, cause) : ctor1str.apply(msg)
+                : cause != null ? ctor1exc.apply(cause) : ctor0.get();
+        }
+    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
index 8df8b6d..fcdb4e4 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicException.java
@@ -2,9 +2,8 @@
 
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
-public class ResultPanicException extends RuntimeException {
+public class ResultPanicException extends PanicException {
     public ResultPanicException() {
     }
 
@@ -26,32 +25,11 @@ public ResultPanicException(Throwable cause) {
         return new Builder();
     }
 
-    public static class Builder {  // TODO perhaps move up to PanicException class
-        protected @Nullable String msg;
-        protected @Nullable Throwable cause;
-
-        protected Builder() {
-            msg = null;
-            cause = null;
-        }
-
-        @Contract("_ -> this")
-        public Builder msg(@Nullable String msg) {
-            this.msg = msg;
-            return this;
-        }
-
-        @Contract("_ -> this")
-        public Builder cause(@Nullable Throwable cause) {
-            this.cause = cause;
-            return this;
-        }
-
+    public static class Builder extends PanicException.Builder {
+        @Override
         public ResultPanicException build() {
-            // This complication is required to ensure that initCause can be set later if not set now.
-            return msg != null
-                ? cause != null ? new ResultPanicException(msg, cause) : new ResultPanicException(msg)
-                : cause != null ? new ResultPanicException(cause) : new ResultPanicException();
+            return build(ResultPanicException::new, ResultPanicException::new,
+                ResultPanicException::new, ResultPanicException::new);
         }
     }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
index af9a52b..d1c62f7 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/ResultPanicWithValueException.java
@@ -9,7 +9,6 @@ public class ResultPanicWithValueException extends ResultPanicException {
     protected @Nullable Object value;
 
     /// To set the cause, use `.builder()`
-    @SuppressWarnings("unused")
     public ResultPanicWithValueException() {
     }
 
@@ -26,15 +25,10 @@ public ResultPanicWithValueException(String message, Throwable cause, @Nullable
         this.value = value;
     }
 
-    @SuppressWarnings("unused")
     public ResultPanicWithValueException(Throwable cause) {
         super(cause);
     }
 
-    protected ResultPanicWithValueException(@NotNull ResultPanicException parent) {
-        this(parent.getMessage(), parent.getCause());
-    }
-
     public static @NotNull ResultPanicWithValueException fromMaybeExcValue(@Nullable Object value, String msg) {
         return switch (value) {
             case null -> new ResultPanicWithValueException(msg);
@@ -93,7 +87,9 @@ public Builder value(Object value) {
 
         @Override
         public ResultPanicWithValueException build() {
-            ResultPanicWithValueException ret = new ResultPanicWithValueException(super.build());
+            ResultPanicWithValueException ret = build(
+                ResultPanicWithValueException::new, ResultPanicWithValueException::new,
+                ResultPanicWithValueException::new, ResultPanicWithValueException::new);
             ret.setValue(m_value);
             return ret;
         }

From 426b5c2a6862eb1434cc8fcf1f9ea90180bca881 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 19:08:19 +0100
Subject: [PATCH 13/45] refactor: Remove unneeded SuppressWarnings

---
 src/main/java/net/marcellperger/mathexpr/util/Util.java     | 3 ---
 src/test/java/net/marcellperger/mathexpr/ObjStringPair.java | 1 -
 2 files changed, 4 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index cae5ab3..b124c19 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -58,13 +58,11 @@ protected Util() {}
         return obj;
     }
 
-    @SuppressWarnings("UnusedReturnValue")
     @Contract("_ -> param1")
     public static <C extends Collection<?>> @NotNull C requireNonEmpty(@NotNull C collection) {
         if(collection.isEmpty()) throw new CollectionSizeException("Argument must not be empty");
         return collection;
     }
-    @SuppressWarnings("UnusedReturnValue")
     @Contract("null -> fail; _ -> param1")
     public static <C extends Collection<?>> @NotNull C requireNonEmptyNonNull(C collection) {
         return requireNonEmpty(Objects.requireNonNull(collection));
@@ -74,7 +72,6 @@ protected Util() {}
         if(collection.isEmpty()) throw new CollectionSizeException(msg);
         return collection;
     }
-    @SuppressWarnings("UnusedReturnValue")
     @Contract("null, _ -> fail; _, _ -> param1")
     public static <C extends Collection<?>> @NotNull C requireNonEmptyNonNull(C collection, String msg) {
         return requireNonEmpty(Objects.requireNonNull(collection), msg);
diff --git a/src/test/java/net/marcellperger/mathexpr/ObjStringPair.java b/src/test/java/net/marcellperger/mathexpr/ObjStringPair.java
index b32ae3c..b708b27 100644
--- a/src/test/java/net/marcellperger/mathexpr/ObjStringPair.java
+++ b/src/test/java/net/marcellperger/mathexpr/ObjStringPair.java
@@ -1,5 +1,4 @@
 package net.marcellperger.mathexpr;
 
-@SuppressWarnings("unused")  // IntelliJ is dumb - it IS used in tests
 public record ObjStringPair(MathSymbol obj, String str) {
 }

From 4b48c014532ba1494ecc8e8092b66ec4fb8f6a2f Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 20:29:26 +0100
Subject: [PATCH 14/45] style: Fix indentation in `.github/dependabot.yml`

---
 .github/dependabot.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index f33a02c..9d8f2d0 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -6,7 +6,7 @@
 
 version: 2
 updates:
- - package-ecosystem: "devcontainers"
-   directory: "/"
-   schedule:
-     interval: weekly
+  - package-ecosystem: "devcontainers"
+    directory: "/"
+    schedule:
+      interval: weekly

From 22fd7849ea048313913f2a5360567bb89ce150e9 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 23:14:06 +0100
Subject: [PATCH 15/45] test: Create a small function mocking util
 (MiniMock.java)

---
 .../marcellperger/mathexpr/util/VoidVal.java  |  14 +-
 .../net/marcellperger/mathexpr/MiniMock.java  | 311 ++++++++++++++++++
 2 files changed, 322 insertions(+), 3 deletions(-)
 create mode 100644 src/test/java/net/marcellperger/mathexpr/MiniMock.java

diff --git a/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java b/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java
index c0db270..ade1e71 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/VoidVal.java
@@ -8,13 +8,21 @@
  * when e.g. you don't actually want to return anything but {@code Function} interface
  * requires it to return instances of a type. Because 'no value' is a type that has
  * EXACTLY ONE instance: nothing ({@code None} / {@code ()} / {@code undefined})*/
-@SuppressWarnings("InstantiationOfUtilityClass")  // not a so-called 'utility class'; Pycharm just thinks it is
 public final class VoidVal {
-    static @NotNull VoidVal INST = new VoidVal();
+    static final @NotNull VoidVal INST = new VoidVal();
 
-    private VoidVal() {}
+    @SuppressWarnings("ConstantValue")  // This is actually called to initialize it to non-null
+    private VoidVal() {
+        if(INST != null) throw new AssertionError(
+            "new VoidVal() should only be called once to create VoidVal.INST");
+    }
 
     public static VoidVal val() {
         return INST;
     }
+
+    @Override
+    public boolean equals(Object obj) {
+        return this == obj;  // there can only be one.
+    }
 }
diff --git a/src/test/java/net/marcellperger/mathexpr/MiniMock.java b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
new file mode 100644
index 0000000..56e2c79
--- /dev/null
+++ b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
@@ -0,0 +1,311 @@
+package net.marcellperger.mathexpr;
+
+import net.marcellperger.mathexpr.util.VoidVal;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+import org.junit.jupiter.api.Assertions;
+
+public class MiniMock {
+    enum ReturnStrategy {
+        VALUE, FUNC
+    }
+
+    public static class BaseMockedCallable<A> {
+        List<A> calls;
+
+        protected void handleCall(A args) {
+            calls.add(args);
+        }
+
+        public void assertCalledOnce() {
+            Assertions.assertEquals(1, calls.size(), "Expected function to be called exactly once.");
+        }
+        public void assertCalledOnceWith(A args) {
+            assertCalledOnce();
+            Assertions.assertEquals(args, calls.getFirst(), "Expected function to called with these args");
+        }
+
+        public void assertNotCalled() {
+            Assertions.assertEquals(0, calls.size(), "Expected function not to be called.");
+        }
+
+        public void reset() {
+            calls.clear();
+        }
+    }
+
+    // TODO there is SO much shared code between these Mocked* classes
+    public static class MockedSupplier<R> extends BaseMockedCallable<VoidVal> implements Supplier<R> {
+        // Option<T> would be so useful right now
+        R returnValue;
+        Supplier<R> returnSupplier;
+        ReturnStrategy returnStrategy;
+
+        public MockedSupplier(R returnValue_) {
+            calls = new ZST_List();
+            returnValue = returnValue_;
+            returnStrategy = ReturnStrategy.VALUE;
+        }
+        public MockedSupplier(Supplier<R> returnSupplier_) {
+            calls = new ZST_List();
+            returnSupplier = returnSupplier_;
+            returnStrategy = ReturnStrategy.FUNC;
+        }
+
+        protected R getReturn() {
+            return switch (returnStrategy) {
+                case VALUE -> returnValue;
+                case FUNC -> returnSupplier.get();
+            };
+        }
+
+        @Override
+        public R get() {
+            handleCall(VoidVal.val());
+            return getReturn();
+        }
+    }
+
+    public static class MockedFunction<T, R> extends BaseMockedCallable<T> implements Function<T, R> {
+        // Option<T> would be so useful right now
+        R returnValue;
+        Function<? super T, ? extends R> returnFunc;
+        ReturnStrategy returnStrategy;
+
+        public MockedFunction(R returnValue_) {
+            calls = new ArrayList<>();
+            returnValue = returnValue_;
+            returnStrategy = ReturnStrategy.VALUE;
+        }
+        public MockedFunction(Function<? super T, ? extends R> returnSupplier_) {
+            calls = new ArrayList<>();
+            returnFunc = returnSupplier_;
+            returnStrategy = ReturnStrategy.FUNC;
+        }
+
+        protected R getReturn(T arg) {
+            return switch (returnStrategy) {
+                case VALUE -> returnValue;
+                case FUNC -> returnFunc.apply(arg);
+            };
+        }
+
+        @Override
+        public R apply(T arg) {
+            handleCall(arg);
+            return getReturn(arg);
+        }
+    }
+
+    public static class MockedPredicate<T> extends BaseMockedCallable<T> implements Predicate<T> {
+        // Option<T> would be so useful right now
+        boolean returnValue;
+        Predicate<? super T> returnFunc;
+        ReturnStrategy returnStrategy;
+
+        public MockedPredicate(boolean returnValue_) {
+            calls = new ArrayList<>();
+            returnValue = returnValue_;
+            returnStrategy = ReturnStrategy.VALUE;
+        }
+        public MockedPredicate(Predicate<? super T> returnSupplier_) {
+            calls = new ArrayList<>();
+            returnFunc = returnSupplier_;
+            returnStrategy = ReturnStrategy.FUNC;
+        }
+
+        protected boolean getReturn(T arg) {
+            return switch (returnStrategy) {
+                case VALUE -> returnValue;
+                case FUNC -> returnFunc.test(arg);
+            };
+        }
+
+        @Override
+        public boolean test(T arg) {
+            handleCall(arg);
+            return getReturn(arg);
+        }
+    }
+
+    // oof, this List interface is monstrously big, with very few defaults!
+    static class ZST_List implements List<VoidVal> {
+        private int m_size = 0;  // I wish this could be long but size() requires int
+
+        public ZST_List() {}
+        public ZST_List(int size) { m_size = size; }
+        @Contract(pure = true)
+        public ZST_List(@NotNull Collection<VoidVal> c) {
+            m_size = c.size();
+        }
+
+
+        private void wantInBounds(int index) {
+            if(index < 0 || index >= m_size) throw new IndexOutOfBoundsException(index);
+        }
+        private void wantInBounds_insert(int index) {
+            if(index < 0 || index > m_size) throw new IndexOutOfBoundsException(index);
+        }
+
+        @Contract(" -> new")
+        private @NotNull @Unmodifiable List<VoidVal> immutableImpl() {
+            return Collections.nCopies(m_size, VoidVal.val());
+        }
+
+        @Override
+        public int size() {
+            return m_size;
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return m_size == 0;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return o == VoidVal.val();  // we contain all VoidVal and nothing else
+        }
+
+        @NotNull
+        @Override
+        public Iterator<VoidVal> iterator() {
+            return immutableImpl().iterator();
+        }
+
+        @NotNull
+        @Override
+        public Object @NotNull [] toArray() {
+            return immutableImpl().toArray();
+        }
+
+        @NotNull
+        @Override
+        public <T> T @NotNull [] toArray(@NotNull T @NotNull [] a) {
+            return immutableImpl().toArray(a);
+        }
+
+        @Override
+        public boolean add(VoidVal voidVal) {
+            ++m_size;
+            return true;
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            if(m_size <= 0) return false;
+            --m_size;
+            return true;
+        }
+
+        @Override
+        public boolean containsAll(@NotNull Collection<?> c) {
+            return m_size != 0 && c.stream().allMatch(o -> o == VoidVal.val());
+        }
+
+        @Override
+        public boolean addAll(@NotNull Collection<? extends VoidVal> c) {
+            if(c.stream().anyMatch(o -> o != VoidVal.val())) throw new ClassCastException("ZST_List can only contain VoidVal");
+            m_size += c.size();
+            return true;
+        }
+
+        @Override
+        public boolean addAll(int index, @NotNull Collection<? extends VoidVal> c) {
+            wantInBounds_insert(index);
+            return addAll(c);
+        }
+
+        @Override
+        public boolean removeAll(@NotNull Collection<?> c) {
+            boolean removeValues = c.contains(VoidVal.val());
+            if(removeValues && m_size != 0) {
+                m_size = 0;
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        public boolean retainAll(@NotNull Collection<?> c) {
+            boolean retainValues = c.contains(VoidVal.val());
+            if (retainValues || m_size == 0) {
+                return false;
+            }
+            m_size = 0;
+            return true;
+        }
+
+        @Override
+        public void clear() {
+            m_size = 0;
+        }
+
+        @Override
+        public VoidVal get(int index) {
+            wantInBounds(index);
+            return VoidVal.val();
+        }
+
+        @Override
+        public VoidVal set(int index, VoidVal element) {
+            wantInBounds(index);
+            if(element != VoidVal.val()) throw new ClassCastException("ZST_List can only contain VoidVal");
+            return VoidVal.val();
+        }
+
+        @Override
+        public void add(int index, VoidVal element) {
+            wantInBounds_insert(index);
+            ++m_size;
+        }
+
+        @Override
+        public VoidVal remove(int index) {
+            wantInBounds(index);
+            --m_size;
+            return VoidVal.val();
+        }
+
+        @Override
+        public int indexOf(Object o) {
+            if(m_size == 0) return -1;
+            return o == VoidVal.val() ? 0 : -1;
+        }
+
+        @Override
+        public int lastIndexOf(Object o) {
+            if(m_size == 0) return -1;
+            return o == VoidVal.val() ? m_size - 1 : -1;
+        }
+
+        // TODO Technically I should make a custom class for this and .iterator()
+        //  as modification IS allowed but I'll do that later.
+        @NotNull
+        @Override
+        public ListIterator<VoidVal> listIterator() {
+            return immutableImpl().listIterator();
+        }
+        @NotNull
+        @Override
+        public ListIterator<VoidVal> listIterator(int index) {
+            return immutableImpl().listIterator(index);
+        }
+
+        @NotNull
+        @Override
+        public List<VoidVal> subList(int fromIndex, int toIndex) {
+            // We just return a copy, because, for us, there ARE no
+            // 'non-structural' changes as only the count matters and there is
+            // only one possible value for each place so the only way to modify it is
+            return new ZST_List(toIndex - fromIndex);
+        }
+    }
+}

From 517ff331c373da438cf13d20c8375c9e7453c50b Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 23:18:31 +0100
Subject: [PATCH 16/45] test(result): Add tests for `map*`, `is*And`

---
 .../mathexpr/util/rs/ResultTest.java          | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index 2d829a1..5f7da5d 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -2,8 +2,12 @@
 
 import org.junit.jupiter.api.Test;
 
+import static net.marcellperger.mathexpr.MiniMock.*;
 import static org.junit.jupiter.api.Assertions.*;
 
+// Some of these tests are somewhat based on Rust's tests for `core::result::Result`
+//  with some additions for all the methods that aren't tested in Rust's tests
+//  so that we test all the non-trivial methods
 class ResultTest {
     Result<Integer, String> getOk() {
         return Result.newOk(314);
@@ -26,26 +30,90 @@ void isErr() {
 
     @Test
     void isOkAnd() {
+        MockedPredicate<Integer> mfFalse = new MockedPredicate<>(false);
+        MockedPredicate<Integer> mfTrue = new MockedPredicate<>(true);
+        {
+            assertTrue(getOk().isOkAnd(mfTrue));
+            mfTrue.assertCalledOnceWith(314);
+            assertFalse(getOk().isOkAnd(mfFalse));
+            mfFalse.assertCalledOnceWith(314);
+        }
+        mfTrue.reset();
+        mfFalse.reset();
+        {
+            assertFalse(getErr().isOkAnd(mfTrue));
+            mfTrue.assertNotCalled();
+            assertFalse(getErr().isOkAnd(mfFalse));
+            mfFalse.assertNotCalled();
+        }
     }
 
     @Test
     void isErrAnd() {
+        MockedPredicate<String> mfFalse = new MockedPredicate<>(false);
+        MockedPredicate<String> mfTrue = new MockedPredicate<>(true);
+        {
+            assertTrue(getErr().isErrAnd(mfTrue));
+            mfTrue.assertCalledOnceWith("TESTING_ERROR");
+            assertFalse(getErr().isErrAnd(mfFalse));
+            mfFalse.assertCalledOnceWith("TESTING_ERROR");
+        }
+        mfTrue.reset();
+        mfFalse.reset();
+        {
+            assertFalse(getOk().isErrAnd(mfTrue));
+            mfTrue.assertNotCalled();
+            assertFalse(getOk().isErrAnd(mfFalse));
+            mfFalse.assertNotCalled();
+        }
     }
 
     @Test
     void map() {
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        assertEquals(Result.newOk(7), Result.<Integer, Integer>newOk(6).map(mfAdd1));
+        mfAdd1.assertCalledOnceWith(6);
+        mfAdd1.reset();
+        assertEquals(Result.newErr(6), Result.<Integer, Integer>newErr(6).map(mfAdd1));
+        mfAdd1.assertNotCalled();
     }
 
     @Test
     void mapOr() {
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        assertEquals(7, Result.<Integer, Integer>newOk(6).mapOr(-1, mfAdd1));
+        mfAdd1.assertCalledOnceWith(6);
+        mfAdd1.reset();
+        assertEquals(-1, Result.<Integer, Integer>newErr(6).mapOr(-1, mfAdd1));
+        mfAdd1.assertNotCalled();
     }
 
     @Test
     void mapOrElse() {
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        MockedFunction<Integer, Integer> mfAdd25 = new MockedFunction<>(i -> i + 25);
+        {
+            assertEquals(7, Result.<Integer, Integer>newOk(6).mapOrElse(mfAdd25, mfAdd1));
+            mfAdd1.assertCalledOnceWith(6);
+            mfAdd25.assertNotCalled();
+        }
+        mfAdd1.reset();
+        mfAdd25.reset();
+        {
+            assertEquals(31, Result.<Integer, Integer>newErr(6).mapOrElse(mfAdd25, mfAdd1));
+            mfAdd1.assertNotCalled();
+            mfAdd25.assertCalledOnceWith(6);
+        }
     }
 
     @Test
     void mapErr() {
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        assertEquals(Result.newErr(7), Result.<Integer, Integer>newErr(6).mapErr(mfAdd1));
+        mfAdd1.assertCalledOnceWith(6);
+        mfAdd1.reset();
+        assertEquals(Result.newOk(6), Result.<Integer, Integer>newOk(6).mapErr(mfAdd1));
+        mfAdd1.assertNotCalled();
     }
 
     @Test

From 64a8ca45782e72fd9c8461c8800c9639ac5773fe Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 5 May 2024 23:21:46 +0100
Subject: [PATCH 17/45] fix: Fix some intellij unused code warnings

---
 .idea/inspectionProfiles/Project_Default.xml           | 2 +-
 src/test/java/net/marcellperger/mathexpr/MiniMock.java | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index e4125d4..a4e99ea 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -6,7 +6,7 @@
       <option name="IGNORE_BUILDER_PATTERN" value="true" />
       <option name="highestModifier" value="package-private" />
     </inspection_tool>
-    <inspection_tool class="unused" enabled="true" level="WARNING" enabled_by_default="true" ignoreAccessors="true" checkParameterExcludingHierarchy="false">
+    <inspection_tool class="unused" enabled="true" level="WARNING" enabled_by_default="true" inner_class="protected" method="protected" ignoreAccessors="true" checkParameterExcludingHierarchy="false">
       <option name="LOCAL_VARIABLE" value="true" />
       <option name="FIELD" value="true" />
       <option name="METHOD" value="true" />
diff --git a/src/test/java/net/marcellperger/mathexpr/MiniMock.java b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
index 56e2c79..1234da7 100644
--- a/src/test/java/net/marcellperger/mathexpr/MiniMock.java
+++ b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
@@ -141,6 +141,7 @@ static class ZST_List implements List<VoidVal> {
 
         public ZST_List() {}
         public ZST_List(int size) { m_size = size; }
+        @SuppressWarnings("unused")
         @Contract(pure = true)
         public ZST_List(@NotNull Collection<VoidVal> c) {
             m_size = c.size();

From bc7558a5d9a0c491531cb08dbb6270dc94f1e3a0 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Mon, 6 May 2024 22:25:24 +0100
Subject: [PATCH 18/45] test: Tests for more Result methods, fix some stuff

---
 .../mathexpr/util/rs/Result.java              |   2 +-
 .../net/marcellperger/mathexpr/MiniMock.java  |  12 ++
 .../mathexpr/util/rs/ResultTest.java          | 118 +++++++++++++++++-
 3 files changed, 129 insertions(+), 3 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 4333434..80d3766 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -146,7 +146,7 @@ default T unwrap() {
         return expect("unwrap() got Err value");
     }
     default T expect(String msg) {
-        return okOpt().orElseThrow(() -> ResultPanicWithValueException.fromMaybeExcValue(err(), msg)).value;
+        return unwrapOrElse((err) -> {throw ResultPanicWithValueException.fromMaybeExcValue(err, msg);});
     }
     // We CANNOT do unwrap_or_default because Java: <rant>
     //  - Static methods cannot be overloaded properly and cannot even be part of an interface
diff --git a/src/test/java/net/marcellperger/mathexpr/MiniMock.java b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
index 1234da7..6e86484 100644
--- a/src/test/java/net/marcellperger/mathexpr/MiniMock.java
+++ b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
@@ -6,6 +6,7 @@
 import org.jetbrains.annotations.Unmodifiable;
 
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -135,6 +136,17 @@ public boolean test(T arg) {
         }
     }
 
+    public static class MockedConsumer<T> extends BaseMockedCallable<T> implements Consumer<T> {
+        public MockedConsumer() {
+            calls = new ArrayList<>();
+        }
+
+        @Override
+        public void accept(T arg) {
+            handleCall(arg);
+        }
+    }
+
     // oof, this List interface is monstrously big, with very few defaults!
     static class ZST_List implements List<VoidVal> {
         private int m_size = 0;  // I wish this could be long but size() requires int
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index 5f7da5d..f32b789 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -2,6 +2,10 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
 import static net.marcellperger.mathexpr.MiniMock.*;
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -117,35 +121,145 @@ void mapErr() {
     }
 
     @Test
-    void ifThenElse() {
+    void ifThenElse_consumer() {
+        MockedConsumer<Integer> intConsumer = new MockedConsumer<>();
+        MockedConsumer<String> strConsumer = new MockedConsumer<>();
+        {
+            getOk().ifThenElse(intConsumer, strConsumer);
+            intConsumer.assertCalledOnceWith(314);
+            strConsumer.assertNotCalled();
+        }
+        intConsumer.reset();
+        strConsumer.reset();
+        {
+            getErr().ifThenElse(intConsumer, strConsumer);
+            intConsumer.assertNotCalled();
+            strConsumer.assertCalledOnceWith("TESTING_ERROR");
+        }
     }
 
     @Test
-    void testIfThenElse() {
+    void ifThenElse_func() {
+        MockedFunction<Integer, String> intFn = new MockedFunction<>("intFn_return");
+        MockedFunction<String, String> strFn = new MockedFunction<>("strFn_return");
+        {
+            assertEquals("intFn_return",  getOk().ifThenElse(intFn, strFn));
+            intFn.assertCalledOnceWith(314);
+            strFn.assertNotCalled();
+        }
+        intFn.reset();
+        strFn.reset();
+        {
+            assertEquals("strFn_return", getErr().ifThenElse(intFn, strFn));
+            intFn.assertNotCalled();
+            strFn.assertCalledOnceWith("TESTING_ERROR");
+        }
     }
 
     @Test
     void inspect() {
+        MockedConsumer<Integer> intCons = new MockedConsumer<>();
+        assertEquals(getOk(), getOk().inspect(intCons));
+        intCons.assertCalledOnceWith(314);
+        intCons.reset();
+        assertEquals(getErr(), getErr().inspect(intCons));
+        intCons.assertNotCalled();
     }
 
     @Test
     void inspectErr() {
+        MockedConsumer<String> strCons = new MockedConsumer<>();
+        assertEquals(getErr(), getErr().inspectErr(strCons));
+        strCons.assertCalledOnceWith("TESTING_ERROR");
+        strCons.reset();
+        assertEquals(getOk(), getOk().inspectErr(strCons));
+        strCons.assertNotCalled();
     }
 
     @Test
     void stream() {
+        assertEquals(List.of(314), getOk().stream().toList());
+        assertEquals(List.of(), getErr().stream().toList());
     }
 
     @Test
     void iterator() {
+        {
+            Iterator<Integer> oks = getOk().iterator();
+            assertTrue(oks.hasNext());
+            assertEquals(314, oks.next());
+            assertFalse(oks.hasNext());
+        }
+        {
+            List<Integer> ls = new ArrayList<>();
+            getOk().iterator().forEachRemaining(ls::add);
+            assertEquals(List.of(314), ls);
+        }
+        {
+            Iterator<Integer> oks = getErr().iterator();
+            assertFalse(oks.hasNext());
+        }
+        {
+            List<Integer> ls = new ArrayList<>();
+            getErr().iterator().forEachRemaining(ls::add);
+            assertEquals(List.of(), ls);
+        }
     }
 
     @Test
     void forEach() {
+        MockedConsumer<Integer> intCons = new MockedConsumer<>();
+        {
+            getOk().forEach(intCons);
+            intCons.assertCalledOnceWith(314);
+        }
+        intCons.reset();
+        {
+            getErr().forEach(intCons);
+            intCons.assertNotCalled();
+        }
     }
 
     @Test
     void unwrap() {
+        assertEquals(314, assertDoesNotThrow(() -> getOk().unwrap()));
+        {
+            Result<Integer, String> err = getErr();
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, err::unwrap);
+            assertEquals("TESTING_ERROR", exc.getValue());
+            assertEquals("unwrap() got Err value: TESTING_ERROR", exc.getMessage());
+            assertNull(exc.getCause(), "Expected no cause when Err is a string");
+        }
+        {
+            MyCustomException customExc = new MyCustomException("CUSTOM_ERR_VALUE");
+            Result<Integer, MyCustomException> err = Result.newErr(customExc);
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, err::unwrap);
+            assertEquals(customExc, exc.getValue());
+            assertEquals("unwrap() got Err value: " +
+                "net.marcellperger.mathexpr.util.rs.ResultTest$MyCustomException:" +
+                " CUSTOM_ERR_VALUE", exc.getMessage());
+            assertEquals(customExc, exc.getCause());
+        }
+    }
+
+    @SuppressWarnings("unused")
+    static class MyCustomException extends RuntimeException {
+        public MyCustomException() {
+        }
+
+        public MyCustomException(String message) {
+            super(message);
+        }
+
+        public MyCustomException(String message, Throwable cause) {
+            super(message, cause);
+        }
+
+        public MyCustomException(Throwable cause) {
+            super(cause);
+        }
     }
 
     @Test

From 2b129b2ac890e80c98a87584dcbfb10e2a6da406 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 7 May 2024 20:10:38 +0100
Subject: [PATCH 19/45] fix: Fix unwrap_err and add test

---
 .../mathexpr/util/rs/Result.java              |  8 +++-
 .../mathexpr/util/rs/ResultTest.java          | 44 ++++++++++++++++++-
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 80d3766..3abec87 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -146,7 +146,9 @@ default T unwrap() {
         return expect("unwrap() got Err value");
     }
     default T expect(String msg) {
-        return unwrapOrElse((err) -> {throw ResultPanicWithValueException.fromMaybeExcValue(err, msg);});
+        return unwrapOrElse((err) -> {
+            throw ResultPanicWithValueException.fromMaybeExcValue(err, msg);
+        });
     }
     // We CANNOT do unwrap_or_default because Java: <rant>
     //  - Static methods cannot be overloaded properly and cannot even be part of an interface
@@ -167,7 +169,9 @@ default T expect(String msg) {
     //  - I really don't want to use reflection, because in strongly typed languages,
     //     my philosophy is "Check as much as possible at compile-time to reduce runtime failure". </rant>
     default E expect_err(String msg) {
-        return errOpt().orElseThrow(() -> ResultPanicWithValueException.fromPlainValue(ok(), msg)).exc;
+        return ifThenElse(ok -> {
+            throw ResultPanicWithValueException.fromPlainValue(ok, msg);
+        }, Function.identity());
     }
     default E unwrap_err() {
         return expect_err("unwrap_err() got Ok value");
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index f32b789..01bb4f9 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -264,14 +264,54 @@ public MyCustomException(Throwable cause) {
 
     @Test
     void expect() {
+        assertEquals(314, assertDoesNotThrow(() -> getOk().expect("EXPECT_MSG")));
+        {
+            Result<Integer, String> err = getErr();
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, () -> err.expect("EXPECT_MSG"));
+            assertEquals("TESTING_ERROR", exc.getValue());
+            assertEquals("EXPECT_MSG: TESTING_ERROR", exc.getMessage());
+            assertNull(exc.getCause(), "Expected no cause when Err is a string");
+        }
+        {
+            MyCustomException customExc = new MyCustomException("CUSTOM_ERR_VALUE");
+            Result<Integer, MyCustomException> err = Result.newErr(customExc);
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, () -> err.expect("EXPECT_MSG"));
+            assertEquals(customExc, exc.getValue());
+            assertEquals("EXPECT_MSG: " +
+                "net.marcellperger.mathexpr.util.rs.ResultTest$MyCustomException:" +
+                " CUSTOM_ERR_VALUE", exc.getMessage());
+            assertEquals(customExc, exc.getCause());
+        }
     }
 
     @Test
-    void expect_err() {
+    void unwrap_err() {
+        assertEquals("TESTING_ERROR", assertDoesNotThrow(() -> getErr().unwrap_err()));
+        {
+            Result<Integer, String> err = getOk();
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, err::unwrap_err);
+            assertEquals(314, exc.getValue());
+            assertEquals("unwrap_err() got Ok value: 314", exc.getMessage());
+            assertNull(exc.getCause(), "Expected no cause for Ok");
+        }
+        {
+            MyCustomException customExc = new MyCustomException("CUSTOM_ERR_VALUE");
+            Result<MyCustomException, Integer> err = Result.newOk(customExc);
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, err::unwrap_err);
+            assertEquals(customExc, exc.getValue());
+            assertEquals("unwrap_err() got Ok value: " +
+                "net.marcellperger.mathexpr.util.rs.ResultTest$MyCustomException:" +
+                " CUSTOM_ERR_VALUE", exc.getMessage());
+            assertNull(exc.getCause(), "Don't set cause for Ok");
+        }
     }
 
     @Test
-    void unwrap_err() {
+    void expect_err() {
     }
 
     @Test

From 6aa7497e233b5e5721cd92943bbb8dd861909a67 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 7 May 2024 20:22:10 +0100
Subject: [PATCH 20/45] fix: Fix Result.andThen, Result.orElse

---
 .../net/marcellperger/mathexpr/util/rs/Result.java   | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 3abec87..77a56fa 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -182,22 +182,22 @@ default E unwrap_err() {
     // or can't even reason about it in the first place.
 
     default <U> Result<U, E> and(Result<U, E> other) {
-        return andThen(() -> other);
+        return andThen((_ok) -> other);
     }
-    default <U> Result<U, E> andThen(Supplier<? extends Result<U, E>> then) {
+    default <U> Result<U, E> andThen(Function<? super T, ? extends Result<U, E>> then) {
         return switch (this) {
-            case Ok<T, E> _ok -> then.get();  // everything normal with `this`, do next
+            case Ok(T value) -> then.apply(value);  // everything normal with `this`, do next
             case Err<T, E> err -> err.cast();
         };
     }
 
     default <E2> Result<T, E2> or(Result<T, E2> other) {
-        return orElse(() -> other);
+        return orElse((_err) -> other);
     }
-    default <E2> Result<T, E2> orElse(Supplier<? extends Result<T, E2>> elseFn) {
+    default <E2> Result<T, E2> orElse(Function<? super E, ? extends Result<T, E2>> elseFn) {
         return switch (this) {
             case Ok<T, E> ok -> ok.cast();
-            case Err<T, E> _err -> elseFn.get();  // `this` failed so try `elseFn` - "You're my only hope"
+            case Err(E err) -> elseFn.apply(err);  // `this` failed so try `elseFn` - "You're my only hope"
         };
     }
 

From 767013a669101328b4415f7a04b06bfbe400933a Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 7 May 2024 20:47:54 +0100
Subject: [PATCH 21/45] test: Finish the tests

---
 .../mathexpr/util/rs/ResultTest.java          | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index 01bb4f9..c2b03c3 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -312,29 +312,101 @@ void unwrap_err() {
 
     @Test
     void expect_err() {
+        assertEquals("TESTING_ERROR", assertDoesNotThrow(() -> getErr().expect_err("EXPECT_ERR_MSG")));
+        {
+            Result<Integer, String> err = getOk();
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, () -> err.expect_err("EXPECT_ERR_MSG"));
+            assertEquals(314, exc.getValue());
+            assertEquals("EXPECT_ERR_MSG: 314", exc.getMessage());
+            assertNull(exc.getCause(), "Expected no cause for Ok");
+        }
+        {
+            MyCustomException customExc = new MyCustomException("CUSTOM_ERR_VALUE");
+            Result<MyCustomException, Integer> err = Result.newOk(customExc);
+            ResultPanicWithValueException exc = assertThrows(
+                ResultPanicWithValueException.class, () -> err.expect_err("EXPECT_ERR_MSG"));
+            assertEquals(customExc, exc.getValue());
+            assertEquals("EXPECT_ERR_MSG: " +
+                "net.marcellperger.mathexpr.util.rs.ResultTest$MyCustomException:" +
+                " CUSTOM_ERR_VALUE", exc.getMessage());
+            assertNull(exc.getCause(), "Don't set cause for Ok");
+        }
     }
 
     @Test
     void and() {
+        assertEquals(Result.newOk(91L), getOk().and(Result.newOk(91L)));
+        assertEquals(Result.newErr("ERR_RIGHT"), getOk().and(Result.newErr("ERR_RIGHT")));
+        assertEquals(Result.newErr("TESTING_ERROR"), getErr().and(Result.newOk(91L)));
+        assertEquals(Result.newErr("TESTING_ERROR"), getErr().and(Result.newErr("ERR_RIGHT")));
     }
 
     @Test
     void andThen() {
+        MockedFunction<Integer, Result<Long, String>> mfOk = new MockedFunction<>(Result.newOk(91L));
+        MockedFunction<Integer, Result<Long, String>> mfErr = new MockedFunction<>(Result.newErr("ERR_RIGHT"));
+        {
+            assertEquals(Result.newOk(91L), getOk().andThen(mfOk));
+            mfOk.assertCalledOnceWith(314);
+            assertEquals(Result.newErr("ERR_RIGHT"), getOk().andThen(mfErr));
+            mfErr.assertCalledOnceWith(314);
+        }
+        mfOk.reset();
+        mfErr.reset();
+        {
+            assertEquals(Result.newErr("TESTING_ERROR"), getErr().andThen(mfOk));
+            mfOk.assertNotCalled();
+            assertEquals(Result.newErr("TESTING_ERROR"), getErr().andThen(mfErr));
+            mfErr.assertNotCalled();
+        }
     }
 
     @Test
     void or() {
+        assertEquals(getOk(), getOk().or(Result.newOk(271)));
+        assertEquals(getOk(), getOk().or(Result.newErr("ERR_RIGHT")));
+        assertEquals(Result.newOk(271), getErr().or(Result.newOk(271)));
+        assertEquals(Result.newErr("ERR_RIGHT"), getErr().or(Result.newErr("ERR_RIGHT")));
     }
 
     @Test
     void orElse() {
+        MockedFunction<String, Result<Integer, String>> mfOk = new MockedFunction<>(Result.newOk(271));
+        MockedFunction<String, Result<Integer, String>> mfErr = new MockedFunction<>(Result.newErr("ERR_RIGHT"));
+        {
+            assertEquals(getOk(), getOk().orElse(mfOk));
+            mfOk.assertNotCalled();
+            assertEquals(getOk(), getOk().orElse(mfErr));
+            mfErr.assertNotCalled();
+        }
+        mfOk.reset();
+        mfErr.reset();
+        {
+            assertEquals(Result.newOk(271), getErr().orElse(mfOk));
+            mfOk.assertCalledOnceWith("TESTING_ERROR");
+            assertEquals(Result.newErr("ERR_RIGHT"), getErr().orElse(mfErr));
+            mfErr.assertCalledOnceWith("TESTING_ERROR");
+        }
     }
 
     @Test
     void unwrapOr() {
+        assertEquals(314, getOk().unwrapOr(-1));
+        assertEquals(-1, getErr().unwrapOr(-1));
     }
 
     @Test
     void unwrapOrElse() {
+        MockedFunction<String, Integer> mf = new MockedFunction<>(271);
+        {
+            assertEquals(314, getOk().unwrapOrElse(mf));
+            mf.assertNotCalled();
+        }
+        mf.reset();
+        {
+            assertEquals(271, getErr().unwrapOrElse(mf));
+            mf.assertCalledOnceWith("TESTING_ERROR");
+        }
     }
 }
\ No newline at end of file

From 0db69686a54a1f0661b41058930f93bbe7547303 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 7 May 2024 20:49:26 +0100
Subject: [PATCH 22/45] style: Use camelCase

---
 .../mathexpr/util/rs/Result.java              |  7 +++----
 .../mathexpr/util/rs/ResultTest.java          | 20 +++++++++----------
 2 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 77a56fa..f016cfc 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -10,7 +10,6 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 
@@ -168,13 +167,13 @@ default T expect(String msg) {
     //     system which would solve the first BP.
     //  - I really don't want to use reflection, because in strongly typed languages,
     //     my philosophy is "Check as much as possible at compile-time to reduce runtime failure". </rant>
-    default E expect_err(String msg) {
+    default E expectErr(String msg) {
         return ifThenElse(ok -> {
             throw ResultPanicWithValueException.fromPlainValue(ok, msg);
         }, Function.identity());
     }
-    default E unwrap_err() {
-        return expect_err("unwrap_err() got Ok value");
+    default E unwrapErr() {
+        return expectErr("unwrapErr() got Ok value");
     }
     // We can't implement into_ok/into_err as Java doesn't have that
     // kind of infallible type and I don't think Java can be that rigorous about
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index c2b03c3..eb8c194 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -287,23 +287,23 @@ void expect() {
     }
 
     @Test
-    void unwrap_err() {
-        assertEquals("TESTING_ERROR", assertDoesNotThrow(() -> getErr().unwrap_err()));
+    void unwrapErr() {
+        assertEquals("TESTING_ERROR", assertDoesNotThrow(() -> getErr().unwrapErr()));
         {
             Result<Integer, String> err = getOk();
             ResultPanicWithValueException exc = assertThrows(
-                ResultPanicWithValueException.class, err::unwrap_err);
+                ResultPanicWithValueException.class, err::unwrapErr);
             assertEquals(314, exc.getValue());
-            assertEquals("unwrap_err() got Ok value: 314", exc.getMessage());
+            assertEquals("unwrapErr() got Ok value: 314", exc.getMessage());
             assertNull(exc.getCause(), "Expected no cause for Ok");
         }
         {
             MyCustomException customExc = new MyCustomException("CUSTOM_ERR_VALUE");
             Result<MyCustomException, Integer> err = Result.newOk(customExc);
             ResultPanicWithValueException exc = assertThrows(
-                ResultPanicWithValueException.class, err::unwrap_err);
+                ResultPanicWithValueException.class, err::unwrapErr);
             assertEquals(customExc, exc.getValue());
-            assertEquals("unwrap_err() got Ok value: " +
+            assertEquals("unwrapErr() got Ok value: " +
                 "net.marcellperger.mathexpr.util.rs.ResultTest$MyCustomException:" +
                 " CUSTOM_ERR_VALUE", exc.getMessage());
             assertNull(exc.getCause(), "Don't set cause for Ok");
@@ -311,12 +311,12 @@ void unwrap_err() {
     }
 
     @Test
-    void expect_err() {
-        assertEquals("TESTING_ERROR", assertDoesNotThrow(() -> getErr().expect_err("EXPECT_ERR_MSG")));
+    void expectErr() {
+        assertEquals("TESTING_ERROR", assertDoesNotThrow(() -> getErr().expectErr("EXPECT_ERR_MSG")));
         {
             Result<Integer, String> err = getOk();
             ResultPanicWithValueException exc = assertThrows(
-                ResultPanicWithValueException.class, () -> err.expect_err("EXPECT_ERR_MSG"));
+                ResultPanicWithValueException.class, () -> err.expectErr("EXPECT_ERR_MSG"));
             assertEquals(314, exc.getValue());
             assertEquals("EXPECT_ERR_MSG: 314", exc.getMessage());
             assertNull(exc.getCause(), "Expected no cause for Ok");
@@ -325,7 +325,7 @@ void expect_err() {
             MyCustomException customExc = new MyCustomException("CUSTOM_ERR_VALUE");
             Result<MyCustomException, Integer> err = Result.newOk(customExc);
             ResultPanicWithValueException exc = assertThrows(
-                ResultPanicWithValueException.class, () -> err.expect_err("EXPECT_ERR_MSG"));
+                ResultPanicWithValueException.class, () -> err.expectErr("EXPECT_ERR_MSG"));
             assertEquals(customExc, exc.getValue());
             assertEquals("EXPECT_ERR_MSG: " +
                 "net.marcellperger.mathexpr.util.rs.ResultTest$MyCustomException:" +

From 8f1f12def78dcbe1610388a5b4bf81c566b39855 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 7 May 2024 20:55:28 +0100
Subject: [PATCH 23/45] test: 100% coverage in Result.java!

---
 .../mathexpr/util/rs/ResultTest.java          | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index eb8c194..e680aa6 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -1,10 +1,13 @@
 package net.marcellperger.mathexpr.util.rs;
 
+import net.marcellperger.mathexpr.util.rs.Result.Ok;
+import net.marcellperger.mathexpr.util.rs.Result.Err;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Optional;
 
 import static net.marcellperger.mathexpr.MiniMock.*;
 import static org.junit.jupiter.api.Assertions.*;
@@ -409,4 +412,22 @@ void unwrapOrElse() {
             mf.assertCalledOnceWith("TESTING_ERROR");
         }
     }
+
+    @Test
+    void test_toString() {
+        assertEquals("Ok(314)", getOk().toString());
+        assertEquals("Err(TESTING_ERROR)", getErr().toString());
+    }
+
+    @Test
+    void okOpt() {
+        assertEquals(Optional.of(new Ok<>(314)), getOk().okOpt());
+        assertEquals(Optional.empty(), getErr().okOpt());
+    }
+
+    @Test
+    void errOpt() {
+        assertEquals(Optional.empty(), getOk().errOpt());
+        assertEquals(Optional.of(new Err<>("TESTING_ERROR")), getErr().errOpt());
+    }
 }
\ No newline at end of file

From a661ea284320c89a65d4766ce140606ee9707ab9 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 7 May 2024 22:52:15 +0100
Subject: [PATCH 24/45] ci: Add coverage test

---
 .github/workflows/maven.yml |  4 ++-
 pom.xml                     | 57 ++++++++++++++++++++++++++++++++-----
 2 files changed, 53 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 688c711..d1b0e0a 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -29,7 +29,9 @@ jobs:
         distribution: 'temurin'
         cache: maven
     - name: Test with Maven
-      run: mvn -B test
+      run: mvn -B -ntp test
+    - name: Check coverage
+      run: mvn -B -ntp verify
 
     # Optional: Uploads the full dependency graph to GitHub to improve the quality of Dependabot alerts this repository can receive
     - name: Update dependency graph
diff --git a/pom.xml b/pom.xml
index ebb128c..e3c7e1c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -28,15 +28,58 @@
         </dependency>
     </dependencies>
     <build>
-         <plugins>
-			<plugin>
+        <plugins>
+            <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.2.5</version>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.2.5</version>
                 <configuration>
                     <failIfNoTests>true</failIfNoTests>
                 </configuration>
-			</plugin>
-		</plugins>
-	</build>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.12</version>
+                <executions>
+                    <execution>
+                        <id>default-prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-report</id>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-check</id>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <rules>
+                                <rule>
+                                    <element>SOURCEFILE</element>
+                                    <includes>
+                                        <include>net/marcellperger/mathexpr/util/rs/Result.java</include>
+                                    </includes>
+                                    <limits>
+                                        <limit>
+                                            <counter>INSTRUCTION</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <!-- We have 100% coverage, let's not loose it -->
+                                            <minimum>100%</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
 </project>

From 8f84785db1677deb85207ac482cff9d995b75a4d Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Wed, 8 May 2024 22:00:17 +0100
Subject: [PATCH 25/45] refactor: Start making Option (some methods
 implemented, not all yet)

---
 .../net/marcellperger/mathexpr/util/Util.java |   8 +
 .../mathexpr/util/rs/Option.java              |  98 ++++++++++++
 .../util/rs/OptionPanicException.java         |  35 +++++
 .../net/marcellperger/mathexpr/MiniMock.java  |   9 ++
 .../mathexpr/util/rs/OptionTest.java          | 143 ++++++++++++++++++
 5 files changed, 293 insertions(+)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/rs/OptionPanicException.java
 create mode 100644 src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java

diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index b124c19..41d26d0 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -10,6 +10,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
 @SuppressWarnings("unused")
@@ -249,4 +250,11 @@ public void forEachRemaining(Consumer<? super T> action) {
             return v;
         };
     }
+
+    public static @NotNull Supplier<VoidVal> runnableToSupplier(Runnable runnable) {
+        return () -> {
+            runnable.run();
+            return VoidVal.val();
+        };
+    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
new file mode 100644
index 0000000..7f82d17
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -0,0 +1,98 @@
+package net.marcellperger.mathexpr.util.rs;
+
+import net.marcellperger.mathexpr.util.Util;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public sealed interface Option<T> {
+    record Some<T>(T value) implements Option<T> {
+        @Contract(pure = true)
+        @Override
+        public @NotNull String toString() {
+            return "Some(" + value + ')';
+        }
+    }
+
+    record None<T>() implements Option<T> {
+        @Contract(" -> new")
+        public <U> @NotNull None<U> cast() {
+            return new None<>();
+        }
+
+        @Contract(pure = true)
+        @Override
+        public @NotNull String toString() {
+            return "None";
+        }
+    }
+
+    @Contract("_ -> new")
+    static <T> @NotNull Some<T> newSome(T value) {
+        return new Some<>(value);
+    }
+
+    @Contract(" -> new")
+    static <T> @NotNull None<T> newNone() {
+        return new None<>();
+    }
+
+    default boolean isSome() {
+        return this instanceof Some<T>;
+    }
+
+    default boolean isNone() {
+        return this instanceof None<T>;
+    }
+
+    default boolean isSomeAnd(Predicate<? super T> predicate) {
+        return switch (this) {
+            case None() -> false;
+            case Some(T value) -> predicate.test(value);
+        };
+    }
+    // I don't think we need as_slice because .stream().toList() / .collect()
+    //  and there are already easy ways of Option -> Collection using .map etc.
+
+    default <U> Option<U> map(Function<? super T, ? extends U> fn) {
+        return switch (this) {
+            case Some(T value) -> new Some<>(fn.apply(value));
+            case None<T> n -> n.cast();
+        };
+    }
+    default <U> U mapOr(U default_, Function<? super T, ? extends U> fn) {
+        return mapOrElse(() -> default_, fn);
+    }
+    default <U> U mapOrElse(Supplier<? extends U> defaultFn, Function<? super T, ? extends U> fn) {
+        return switch (this) {
+            case Some(T value) -> fn.apply(value);
+            case None() -> defaultFn.get();
+        };
+    }
+    default Option<T> mapErr(Runnable noneFn) {  // there is nothing to map from or to (None -> None)!
+        if(isNone()) noneFn.run();
+        return this;
+    }
+
+    // not Rust functions, but provides more logical argument order
+    // (if/else vs else/if) than mapOrElse
+    default void ifThenElse(Consumer<? super T> someFn, Runnable noneFn) {
+        mapOrElse(Util.runnableToSupplier(noneFn), Util.consumerToFunction(someFn));
+    }
+    default <U> U ifThenElse(Function<? super T, ? extends U> someFn, Supplier<? extends U> noneFn) {
+        return mapOrElse(noneFn, someFn);
+    }
+
+    default Option<T> inspect(Consumer<? super T> fn) {
+        return map(Util.consumerToIdentityFunc(fn));
+    }
+    // not in Rust but could be useful (same as mapErr)
+    default Option<T> inspectErr(Runnable noneFn) {
+        if(isNone()) noneFn.run();
+        return this;
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/OptionPanicException.java b/src/main/java/net/marcellperger/mathexpr/util/rs/OptionPanicException.java
new file mode 100644
index 0000000..b0fb89a
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/OptionPanicException.java
@@ -0,0 +1,35 @@
+package net.marcellperger.mathexpr.util.rs;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+public class OptionPanicException extends PanicException {
+    public OptionPanicException() {
+    }
+
+    public OptionPanicException(String message) {
+        super(message);
+    }
+
+    public OptionPanicException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public OptionPanicException(Throwable cause) {
+        super(cause);
+    }
+
+    @SuppressWarnings("unused")  // may be used later
+    @Contract(value = " -> new", pure = true)
+    public static @NotNull Builder builder() {
+        return new Builder();
+    }
+
+    public static class Builder extends PanicException.Builder {
+        @Override
+        public OptionPanicException build() {
+            return build(OptionPanicException::new, OptionPanicException::new,
+                OptionPanicException::new, OptionPanicException::new);
+        }
+    }
+}
diff --git a/src/test/java/net/marcellperger/mathexpr/MiniMock.java b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
index 6e86484..e6fb583 100644
--- a/src/test/java/net/marcellperger/mathexpr/MiniMock.java
+++ b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
@@ -147,6 +147,15 @@ public void accept(T arg) {
         }
     }
 
+    public static class MockedRunnable extends BaseMockedCallable<VoidVal> implements Runnable {
+        public MockedRunnable() {
+            calls = new ZST_List();
+        }
+
+        @Override
+        public void run() { handleCall(VoidVal.val()); }
+    }
+
     // oof, this List interface is monstrously big, with very few defaults!
     static class ZST_List implements List<VoidVal> {
         private int m_size = 0;  // I wish this could be long but size() requires int
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
new file mode 100644
index 0000000..40ac0f5
--- /dev/null
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -0,0 +1,143 @@
+package net.marcellperger.mathexpr.util.rs;
+
+import net.marcellperger.mathexpr.MiniMock.*;
+import net.marcellperger.mathexpr.util.rs.Option.Some;
+import net.marcellperger.mathexpr.util.rs.Option.None;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class OptionTest {
+    Some<Integer> getSome() {
+        return Option.newSome(314);
+    }
+    None<Integer> getNone() {
+        return Option.newNone();
+    }
+
+    @Test
+    void isSome() {
+        assertTrue(getSome().isSome());
+        assertFalse(getNone().isSome());
+    }
+
+    @Test
+    void isNone() {
+        assertFalse(getSome().isNone());
+        assertTrue(getNone().isNone());
+    }
+
+    @Test
+    void isSomeAnd() {
+        MockedPredicate<Integer> mfFalse = new MockedPredicate<>(false);
+        MockedPredicate<Integer> mfTrue = new MockedPredicate<>(true);
+        {
+            assertTrue(getSome().isSomeAnd(mfTrue));
+            mfTrue.assertCalledOnceWith(314);
+            assertFalse(getSome().isSomeAnd(mfFalse));
+            mfFalse.assertCalledOnceWith(314);
+        }
+        mfTrue.reset();
+        mfFalse.reset();
+        {
+            assertFalse(getNone().isSomeAnd(mfTrue));
+            mfTrue.assertNotCalled();
+            assertFalse(getNone().isSomeAnd(mfFalse));
+            mfFalse.assertNotCalled();
+        }
+    }
+
+    @Test
+    void map() {
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        assertEquals(Option.newSome(7), Option.newSome(6).map(mfAdd1));
+        mfAdd1.assertCalledOnceWith(6);
+        mfAdd1.reset();
+        assertEquals(Option.newNone(), Option.<Integer>newNone().map(mfAdd1));
+        mfAdd1.assertNotCalled();
+    }
+
+    @Test
+    void mapOr() {
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        assertEquals(7, Option.newSome(6).mapOr(-1, mfAdd1));
+        mfAdd1.assertCalledOnceWith(6);
+        mfAdd1.reset();
+        assertEquals(-1, Option.<Integer>newNone().mapOr(-1, mfAdd1));
+        mfAdd1.assertNotCalled();
+    }
+
+    @Test
+    void mapOrElse() {
+        MockedSupplier<Integer> mSupplier = new MockedSupplier<>(-6);
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        {
+            assertEquals(7, Option.newSome(6).mapOrElse(mSupplier, mfAdd1));
+            mfAdd1.assertCalledOnceWith(6);
+            mSupplier.assertNotCalled();
+        }
+        mfAdd1.reset();
+        mSupplier.reset();
+        {
+            assertEquals(-6, Option.<Integer>newNone().mapOrElse(mSupplier, mfAdd1));
+            mfAdd1.assertNotCalled();
+            mSupplier.assertCalledOnce();
+        }
+    }
+
+    @Test
+    void ifThenElse__func_supp() {
+        MockedSupplier<Integer> mSupplier = new MockedSupplier<>(-6);
+        MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
+        {
+            assertEquals(7, Option.newSome(6).ifThenElse(mfAdd1, mSupplier));
+            mfAdd1.assertCalledOnceWith(6);
+            mSupplier.assertNotCalled();
+        }
+        mfAdd1.reset();
+        mSupplier.reset();
+        {
+            assertEquals(-6, Option.<Integer>newNone().ifThenElse(mfAdd1, mSupplier));
+            mfAdd1.assertNotCalled();
+            mSupplier.assertCalledOnce();
+        }
+    }
+
+    @Test
+    void ifThenElse__cons_runnable() {
+        MockedConsumer<Integer> mCons = new MockedConsumer<>();
+        MockedRunnable mRunnable = new MockedRunnable();
+        {
+            getSome().ifThenElse(mCons, mRunnable);
+            mCons.assertCalledOnceWith(314);
+            mRunnable.assertNotCalled();
+        }
+        mCons.reset();
+        mRunnable.reset();
+        {
+            getNone().ifThenElse(mCons, mRunnable);
+            mCons.assertNotCalled();
+            mRunnable.assertCalledOnce();
+        }
+    }
+
+    @Test
+    void inspect() {
+        MockedConsumer<Integer> intCons = new MockedConsumer<>();
+        assertEquals(getSome(), getSome().inspect(intCons));
+        intCons.assertCalledOnceWith(314);
+        intCons.reset();
+        assertEquals(getNone(), getNone().inspect(intCons));
+        intCons.assertNotCalled();
+    }
+
+    @Test
+    void inspectErr() {
+        MockedRunnable mRunnable = new MockedRunnable();
+        assertEquals(getNone(), getNone().inspectErr(mRunnable));
+        mRunnable.assertCalledOnce();
+        mRunnable.reset();
+        assertEquals(getSome(), getSome().inspectErr(mRunnable));
+        mRunnable.assertNotCalled();
+    }
+}
\ No newline at end of file

From 9c6d1f13cd9e43c4c507e720ad7a7757decde716 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Wed, 8 May 2024 22:10:34 +0100
Subject: [PATCH 26/45] refactor: iteration methods on Option

---
 .../mathexpr/util/rs/Option.java              | 23 ++++++++-
 .../mathexpr/util/rs/OptionTest.java          | 48 +++++++++++++++++++
 2 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index 7f82d17..7a7f430 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -4,12 +4,15 @@
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Collections;
+import java.util.Iterator;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
+import java.util.stream.Stream;
 
-public sealed interface Option<T> {
+public sealed interface Option<T> extends Iterable<T> {
     record Some<T>(T value) implements Option<T> {
         @Contract(pure = true)
         @Override
@@ -95,4 +98,22 @@ default Option<T> inspectErr(Runnable noneFn) {
         if(isNone()) noneFn.run();
         return this;
     }
+
+    // .iter()-esque methods: why does Java have SO MANY - one is enough.
+    default Stream<T> stream() {
+        return mapOrElse(Stream::empty, Stream::of);
+    }
+    // Iterable automatically implements `spliterator()` for us
+    @NotNull
+    @Override
+    default Iterator<T> iterator() {
+        return switch (this) {
+            case Some(T value) -> Util.singleItemIterator(value);
+            case None() -> Collections.emptyIterator();
+        };
+    }
+    @Override
+    default void forEach(Consumer<? super T> action) {
+        map(Util.consumerToFunction(action));
+    }
 }
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index 40ac0f5..1d1d6ef 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -5,6 +5,10 @@
 import net.marcellperger.mathexpr.util.rs.Option.None;
 import org.junit.jupiter.api.Test;
 
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 class OptionTest {
@@ -140,4 +144,48 @@ void inspectErr() {
         assertEquals(getSome(), getSome().inspectErr(mRunnable));
         mRunnable.assertNotCalled();
     }
+
+    @Test
+    void stream() {
+        assertEquals(List.of(314), getSome().stream().toList());
+        assertEquals(List.of(), getNone().stream().toList());
+    }
+
+    @Test
+    void iterator() {
+        {
+            Iterator<Integer> oks = getSome().iterator();
+            assertTrue(oks.hasNext());
+            assertEquals(314, oks.next());
+            assertFalse(oks.hasNext());
+        }
+        {
+            List<Integer> ls = new ArrayList<>();
+            getSome().iterator().forEachRemaining(ls::add);
+            assertEquals(List.of(314), ls);
+        }
+        {
+            Iterator<Integer> oks = getNone().iterator();
+            assertFalse(oks.hasNext());
+        }
+        {
+            List<Integer> ls = new ArrayList<>();
+            getNone().iterator().forEachRemaining(ls::add);
+            assertEquals(List.of(), ls);
+        }
+    }
+
+    @Test
+    void forEach() {
+        MockedConsumer<Integer> intCons = new MockedConsumer<>();
+        {
+            getSome().forEach(intCons);
+            intCons.assertCalledOnceWith(314);
+        }
+        intCons.reset();
+        {
+            getNone().forEach(intCons);
+            intCons.assertNotCalled();
+        }
+    }
 }
\ No newline at end of file

From 23ea42493e3a7d4de63d705abac149509c52be1c Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 9 May 2024 21:28:02 +0100
Subject: [PATCH 27/45] refactor: Add more methods on Option, fix ambiguous
 method

---
 .../mathexpr/util/rs/Option.java              | 25 ++++++++++-
 .../mathexpr/util/rs/OptionTest.java          | 45 +++++++++++++++++--
 2 files changed, 64 insertions(+), 6 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index 7a7f430..1b76ea6 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -76,14 +76,16 @@ default <U> U mapOrElse(Supplier<? extends U> defaultFn, Function<? super T, ? e
             case None() -> defaultFn.get();
         };
     }
-    default Option<T> mapErr(Runnable noneFn) {  // there is nothing to map from or to (None -> None)!
+    // there is nothing to map from or to (None -> None)! so this is Runnable
+    // so this is the same as inspectErr. It's here for consistency with Result
+    default Option<T> mapErr(Runnable noneFn) {
         if(isNone()) noneFn.run();
         return this;
     }
 
     // not Rust functions, but provides more logical argument order
     // (if/else vs else/if) than mapOrElse
-    default void ifThenElse(Consumer<? super T> someFn, Runnable noneFn) {
+    default void ifThenElse_void(Consumer<? super T> someFn, Runnable noneFn) {
         mapOrElse(Util.runnableToSupplier(noneFn), Util.consumerToFunction(someFn));
     }
     default <U> U ifThenElse(Function<? super T, ? extends U> someFn, Supplier<? extends U> noneFn) {
@@ -116,4 +118,23 @@ default Iterator<T> iterator() {
     default void forEach(Consumer<? super T> action) {
         map(Util.consumerToFunction(action));
     }
+
+    default T unwrapOr(T default_) {
+        return unwrapOrElse(() -> default_);
+    }
+    default T unwrapOrElse(Supplier<? extends T> ifNone) {
+        return mapOrElse(ifNone, Function.identity());
+    }
+    // no unwrap_or_default (see Result.java for big explanation)
+    default T expect(String msg) {
+        return unwrapOrElse(() -> {
+            throw new OptionPanicException(msg);
+        });
+    }
+    default T unwrap() {
+        return expect("Option.unwrap() got None value");
+    }
+    // no insert / get_or_insert(_*) / take(_if) / replace
+    // (as record is immutable in Java)
+    // TODO unwrap, check Rust docs
 }
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index 1d1d6ef..2fba0d7 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -90,7 +90,7 @@ void mapOrElse() {
     }
 
     @Test
-    void ifThenElse__func_supp() {
+    void ifThenElse() {
         MockedSupplier<Integer> mSupplier = new MockedSupplier<>(-6);
         MockedFunction<Integer, Integer> mfAdd1 = new MockedFunction<>(i -> i + 1);
         {
@@ -108,18 +108,18 @@ void ifThenElse__func_supp() {
     }
 
     @Test
-    void ifThenElse__cons_runnable() {
+    void ifThenElse_void() {
         MockedConsumer<Integer> mCons = new MockedConsumer<>();
         MockedRunnable mRunnable = new MockedRunnable();
         {
-            getSome().ifThenElse(mCons, mRunnable);
+            getSome().ifThenElse_void(mCons, mRunnable);
             mCons.assertCalledOnceWith(314);
             mRunnable.assertNotCalled();
         }
         mCons.reset();
         mRunnable.reset();
         {
-            getNone().ifThenElse(mCons, mRunnable);
+            getNone().ifThenElse_void(mCons, mRunnable);
             mCons.assertNotCalled();
             mRunnable.assertCalledOnce();
         }
@@ -188,4 +188,41 @@ void forEach() {
             intCons.assertNotCalled();
         }
     }
+
+    @Test
+    void unwrapOr() {
+        assertEquals(314, getSome().unwrapOr(-1));
+        assertEquals(-1, getNone().unwrapOr(-1));
+    }
+
+    @Test
+    void unwrapOrElse() {
+        MockedSupplier<Integer> ms = new MockedSupplier<>(271);
+        {
+            assertEquals(314, getSome().unwrapOrElse(ms));
+            ms.assertNotCalled();
+        }
+        ms.reset();
+        {
+            assertEquals(271, getNone().unwrapOrElse(ms));
+            ms.assertCalledOnce();
+        }
+    }
+
+    @Test
+    void expect() {
+        assertEquals(314, assertDoesNotThrow(() -> getSome().expect("EXPECT_MSG")));
+        Option<Integer> n = getNone();
+        OptionPanicException exc = assertThrows(OptionPanicException.class, () -> n.expect("EXPECT_MSG"));
+        assertEquals("EXPECT_MSG", exc.getMessage());
+        assertNull(exc.getCause(), "Expected no cause for Option.expect()");
+    }
+
+    @Test
+    void unwrap() {
+        assertEquals(314, assertDoesNotThrow(() -> getSome().unwrap()));
+        OptionPanicException exc = assertThrows(OptionPanicException.class, getNone()::unwrap);
+        assertEquals("Option.unwrap() got None value", exc.getMessage());
+        assertNull(exc.getCause(), "Expected no cause for Option.unwrap()");
+    }
 }
\ No newline at end of file

From 23755767ff49804d5aa42da4d301cc39330be979 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 9 May 2024 22:24:45 +0100
Subject: [PATCH 28/45] refactor: Add more methods on Option (and, or, okOr,
 filter)

---
 .../mathexpr/util/rs/Option.java              | 37 ++++++-
 .../mathexpr/util/rs/OptionTest.java          | 96 +++++++++++++++++++
 2 files changed, 132 insertions(+), 1 deletion(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index 1b76ea6..2ef9aa8 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -134,7 +134,42 @@ default T expect(String msg) {
     default T unwrap() {
         return expect("Option.unwrap() got None value");
     }
+
+    default <E> Result<T, E> okOr(E err) {
+        return ifThenElse(Result::newOk, () -> Result.newErr(err));
+    }
+    default <E> Result<T, E> okOrElse(Supplier<? extends E> errSupplier) {
+        return ifThenElse(Result::newOk, () -> Result.newErr(errSupplier.get()));
+    }
+
+    default <U> Option<U> and(Option<U> right) {
+        return andThen((_v) -> right);
+    }
+    default <U> Option<U> andThen(Function<? super T, ? extends Option<U>> fn) {
+        return switch (this) {
+            case Some(T value) -> fn.apply(value);
+            case None<T> n -> n.cast();
+        };
+    }
+
+    default Option<T> or(Option<T> right) {
+        return orElse(() -> right);
+    }
+    default Option<T> orElse(Supplier<? extends Option<T>> orFn) {
+        return switch (this) {
+            case Some<T> s -> s;
+            case None() -> orFn.get();
+        };
+    }
+
+    default Option<T> filter(Predicate<? super T> predicate) {
+        return switch (this) {
+            case Some(T value) -> predicate.test(value) ? this : newNone();
+            case None<T> n -> n;
+        };
+    }
+
     // no insert / get_or_insert(_*) / take(_if) / replace
     // (as record is immutable in Java)
-    // TODO unwrap, check Rust docs
+    // TODO check Rust docs
 }
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index 2fba0d7..acde124 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -225,4 +225,100 @@ void unwrap() {
         assertEquals("Option.unwrap() got None value", exc.getMessage());
         assertNull(exc.getCause(), "Expected no cause for Option.unwrap()");
     }
+
+    @Test
+    void okOr() {
+        assertEquals(Result.newOk(314), getSome().okOr("ERR_ARG"));
+        assertEquals(Result.newErr("ERR_ARG"), getNone().okOr("ERR_ARG"));
+    }
+
+    @Test
+    void okOrElse() {
+        MockedSupplier<String> ms = new MockedSupplier<>("ERR_FN_RETURN");
+        {
+            assertEquals(Result.newOk(314), getSome().okOrElse(ms));
+            ms.assertNotCalled();
+        }
+        ms.reset();
+        {
+            assertEquals(Result.newErr("ERR_FN_RETURN"), getNone().okOrElse(ms));
+            ms.assertCalledOnce();
+        }
+    }
+
+    @Test
+    void and() {
+        assertEquals(Option.newSome(91L), getSome().and(Option.newSome(91L)));
+        assertEquals(Option.newNone(), getSome().and(Option.newNone()));
+        assertEquals(Option.newNone(), getNone().and(Option.newSome(91L)));
+        assertEquals(Option.newNone(), getNone().and(getNone()));
+    }
+
+    @Test
+    void andThen() {
+        MockedFunction<Integer, Option<Long>> mfOk = new MockedFunction<>(Option.newSome(91L));
+        MockedFunction<Integer, Option<Long>> mfErr = new MockedFunction<>(Option.newNone());
+        {
+            assertEquals(Option.newSome(91L), getSome().andThen(mfOk));
+            mfOk.assertCalledOnceWith(314);
+            assertEquals(Option.newNone(), getSome().andThen(mfErr));
+            mfErr.assertCalledOnceWith(314);
+        }
+        mfOk.reset();
+        mfErr.reset();
+        {
+            assertEquals(Option.newNone(), getNone().andThen(mfOk));
+            mfOk.assertNotCalled();
+            assertEquals(Option.newNone(), getNone().andThen(mfErr));
+            mfErr.assertNotCalled();
+        }
+    }
+
+    @Test
+    void filter() {
+        MockedPredicate<Integer> mTrue = new MockedPredicate<>(true);
+        MockedPredicate<Integer> mFalse = new MockedPredicate<>(false);
+        {
+            assertEquals(getSome(), getSome().filter(mTrue));
+            mTrue.assertCalledOnceWith(314);
+            assertEquals(getNone(), getSome().filter(mFalse));
+            mFalse.assertCalledOnceWith(314);
+        }
+        mTrue.reset();
+        mFalse.reset();
+        {
+            assertEquals(getNone(), getNone().filter(mTrue));
+            mTrue.assertNotCalled();
+            assertEquals(getNone(), getNone().filter(mFalse));
+            mFalse.assertNotCalled();
+        }
+    }
+
+    @Test
+    void or() {
+        assertEquals(getSome(), getSome().or(Option.newSome(271)));
+        assertEquals(getSome(), getSome().or(getNone()));
+        assertEquals(Option.newSome(271), getNone().or(Option.newSome(271)));
+        assertEquals(getNone(), getNone().or(getNone()));
+    }
+
+    @Test
+    void orElse() {
+        MockedSupplier<Option<Integer>> mSome = new MockedSupplier<>(Option.newSome(271));
+        MockedSupplier<Option<Integer>> mNone = new MockedSupplier<>(Option.newNone());
+        {
+            assertEquals(getSome(), getSome().orElse(mSome));
+            mSome.assertNotCalled();
+            assertEquals(getSome(), getSome().orElse(mNone));
+            mNone.assertNotCalled();
+        }
+        mSome.reset();
+        mNone.reset();
+        {
+            assertEquals(Option.newSome(271), getNone().orElse(mSome));
+            mSome.assertCalledOnce();
+            assertEquals(Option.newNone(), getNone().orElse(mNone));
+            mNone.assertCalledOnce();
+        }
+    }
 }
\ No newline at end of file

From 5736c50791339fac06d55161b595ccbeedef3a2f Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 9 May 2024 22:44:35 +0100
Subject: [PATCH 29/45] refactor: Add xor

---
 .../net/marcellperger/mathexpr/util/rs/Option.java | 14 ++++++++++++--
 .../marcellperger/mathexpr/util/rs/OptionTest.java | 10 +++++++++-
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index 2ef9aa8..6013fb4 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -13,6 +13,7 @@
 import java.util.stream.Stream;
 
 public sealed interface Option<T> extends Iterable<T> {
+    // hashCode, equals are automatically implemented for `record`s
     record Some<T>(T value) implements Option<T> {
         @Contract(pure = true)
         @Override
@@ -169,7 +170,16 @@ default Option<T> filter(Predicate<? super T> predicate) {
         };
     }
 
+    default Option<T> xor(Option<T> right) {
+        return switch (this) {  // I wish this implementation was more elegant
+            case Some<T> left -> right.isNone() ? left : newNone();
+            case None() -> right;
+        };
+    }
+
     // no insert / get_or_insert(_*) / take(_if) / replace
-    // (as record is immutable in Java)
-    // TODO check Rust docs
+    //  (as record is immutable in Java)
+    // no (un)zip(_with) because no tuples  in Java (will do if needed tho)
+    // rest are `impl`s on compound types which Java can't do
+    //  (see Result.java for detailed explanation), can do static method if we need it so much
 }
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index acde124..170da12 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -298,7 +298,7 @@ void filter() {
     void or() {
         assertEquals(getSome(), getSome().or(Option.newSome(271)));
         assertEquals(getSome(), getSome().or(getNone()));
-        assertEquals(Option.newSome(271), getNone().or(Option.newSome(271)));
+        assertEquals(getSome(), getNone().or(getSome()));
         assertEquals(getNone(), getNone().or(getNone()));
     }
 
@@ -321,4 +321,12 @@ void orElse() {
             mNone.assertCalledOnce();
         }
     }
+
+    @Test
+    void xor() {
+        assertEquals(getNone(), getSome().xor(Option.newSome(271)));
+        assertEquals(getSome(), getSome().xor(getNone()));
+        assertEquals(getSome(), getNone().xor(getSome()));
+        assertEquals(getNone(), getNone().xor(getNone()));
+    }
 }
\ No newline at end of file

From 49d4d6f92ae3a4d2798f3430ca3d2b98544ccd56 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 9 May 2024 22:47:57 +0100
Subject: [PATCH 30/45] refactor: Add remaining tests for 100% coverage in
 `Option`

---
 .../mathexpr/util/rs/OptionTest.java             | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index 170da12..2637020 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -89,6 +89,16 @@ void mapOrElse() {
         }
     }
 
+    @Test
+    void mapErr() {
+        MockedRunnable mRunnable = new MockedRunnable();
+        assertEquals(getNone(), getNone().mapErr(mRunnable));
+        mRunnable.assertCalledOnce();
+        mRunnable.reset();
+        assertEquals(getSome(), getSome().mapErr(mRunnable));
+        mRunnable.assertNotCalled();
+    }
+
     @Test
     void ifThenElse() {
         MockedSupplier<Integer> mSupplier = new MockedSupplier<>(-6);
@@ -329,4 +339,10 @@ void xor() {
         assertEquals(getSome(), getNone().xor(getSome()));
         assertEquals(getNone(), getNone().xor(getNone()));
     }
+
+    @Test
+    void test_toString() {
+        assertEquals("Some(314)", getSome().toString());
+        assertEquals("None", getNone().toString());
+    }
 }
\ No newline at end of file

From 2cd71699ebc5147c67301de54b86774619fa5e5a Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 9 May 2024 22:51:52 +0100
Subject: [PATCH 31/45] ci: Add Result.java to 100% coverage group

---
 pom.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pom.xml b/pom.xml
index e3c7e1c..7c5ad6f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -65,6 +65,7 @@
                                     <element>SOURCEFILE</element>
                                     <includes>
                                         <include>net/marcellperger/mathexpr/util/rs/Result.java</include>
+                                        <include>net/marcellperger/mathexpr/util/rs/Option.java</include>
                                     </includes>
                                     <limits>
                                         <limit>

From cc4171c65b5a096d184f882a11e6fe970872c77f Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 20:59:39 +0100
Subject: [PATCH 32/45] refactor: Make Result/Option new* return the base class

This is so that it is different to the plain old constructor.
---
 .../java/net/marcellperger/mathexpr/util/rs/Option.java     | 5 +++--
 .../java/net/marcellperger/mathexpr/util/rs/Result.java     | 5 +++--
 .../java/net/marcellperger/mathexpr/util/rs/OptionTest.java | 6 ++----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index 6013fb4..74b69cd 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -35,13 +35,14 @@ record None<T>() implements Option<T> {
         }
     }
 
+    // Same as new Some/None but return Option
     @Contract("_ -> new")
-    static <T> @NotNull Some<T> newSome(T value) {
+    static <T> @NotNull Option<T> newSome(T value) {
         return new Some<>(value);
     }
 
     @Contract(" -> new")
-    static <T> @NotNull None<T> newNone() {
+    static <T> @NotNull Option<T> newNone() {
         return new None<>();
     }
 
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index f016cfc..e1df7d9 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -43,10 +43,11 @@ public String toString() {
         }
     }
 
-    static <T, E> Ok<T, E> newOk(T value) {
+    // same as new Ok/Err but return Option
+    static <T, E> Result<T, E> newOk(T value) {
         return new Ok<>(value);
     }
-    static <T, E> Err<T, E> newErr(E err) {
+    static <T, E> Result<T, E> newErr(E err) {
         return new Err<>(err);
     }
 
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index 2637020..c3f3e68 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -1,8 +1,6 @@
 package net.marcellperger.mathexpr.util.rs;
 
 import net.marcellperger.mathexpr.MiniMock.*;
-import net.marcellperger.mathexpr.util.rs.Option.Some;
-import net.marcellperger.mathexpr.util.rs.Option.None;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
@@ -12,10 +10,10 @@
 import static org.junit.jupiter.api.Assertions.*;
 
 class OptionTest {
-    Some<Integer> getSome() {
+    Option<Integer> getSome() {
         return Option.newSome(314);
     }
-    None<Integer> getNone() {
+    Option<Integer> getNone() {
         return Option.newNone();
     }
 

From fb1751f70be4aa8b8a1f550a62ca24c638ea6de8 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 22:01:54 +0100
Subject: [PATCH 33/45] How does NotNull work on CI - is it checked?

---
 .../marcellperger/mathexpr/util/rs/ResultTest.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index e680aa6..e92b3ee 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -2,6 +2,7 @@
 
 import net.marcellperger.mathexpr.util.rs.Result.Ok;
 import net.marcellperger.mathexpr.util.rs.Result.Err;
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
@@ -430,4 +431,17 @@ void errOpt() {
         assertEquals(Optional.empty(), getOk().errOpt());
         assertEquals(Optional.of(new Err<>("TESTING_ERROR")), getErr().errOpt());
     }
+
+    void x(@NotNull Object arg) {
+        System.out.println("arg = " + arg);
+    }
+    @Test
+    void whatDoesNotNullDoOnCI() {
+        try {
+            x(null);
+        } catch (IllegalArgumentException e) {
+            fail("It checks for @NotNull", e);
+        }
+        fail("It does not check @NotNull");
+    }
 }
\ No newline at end of file

From df8318f5fb9eb31ef81e5adb659eeca7a2dd4225 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 22:05:38 +0100
Subject: [PATCH 34/45] fix: Remove experiment

Seems that it isn't checked on CI, so no reason (other than debugging) to make IntelliJ check for it
---
 .../mathexpr/util/rs/ResultTest.java             | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index e92b3ee..a042276 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -1,8 +1,7 @@
 package net.marcellperger.mathexpr.util.rs;
 
-import net.marcellperger.mathexpr.util.rs.Result.Ok;
 import net.marcellperger.mathexpr.util.rs.Result.Err;
-import org.jetbrains.annotations.NotNull;
+import net.marcellperger.mathexpr.util.rs.Result.Ok;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
@@ -431,17 +430,4 @@ void errOpt() {
         assertEquals(Optional.empty(), getOk().errOpt());
         assertEquals(Optional.of(new Err<>("TESTING_ERROR")), getErr().errOpt());
     }
-
-    void x(@NotNull Object arg) {
-        System.out.println("arg = " + arg);
-    }
-    @Test
-    void whatDoesNotNullDoOnCI() {
-        try {
-            x(null);
-        } catch (IllegalArgumentException e) {
-            fail("It checks for @NotNull", e);
-        }
-        fail("It does not check @NotNull");
-    }
 }
\ No newline at end of file

From 861ae628047f8837e8c206887bfb635aa71c7d27 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 22:08:52 +0100
Subject: [PATCH 35/45] fix: Use ifThenElse_void for Result as well

---
 .../java/net/marcellperger/mathexpr/util/rs/Result.java     | 4 +++-
 .../java/net/marcellperger/mathexpr/util/rs/ResultTest.java | 6 +++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index e1df7d9..3873586 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -110,7 +110,9 @@ default <E2> Result<T, E2> mapErr(Function<? super E, ? extends E2> op) {
     }
 
     // not a Rust function. Similar to mapOrElse but reversed arguments
-    default void ifThenElse(Consumer<? super T> okFn, Consumer<? super E> errFn) {
+    default void ifThenElse_void(Consumer<? super T> okFn, Consumer<? super E> errFn) {
+        // This _void variant exists (instead of an overload) to avoid Java complaining
+        // about ambiguous arguments when passing method references
         mapOrElse(Util.consumerToFunction(errFn), Util.consumerToFunction(okFn));
     }
     default <U> U ifThenElse(Function<? super T, ? extends U> okFn, Function<? super E, ? extends U> errFn) {
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index a042276..a401ea6 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -124,18 +124,18 @@ void mapErr() {
     }
 
     @Test
-    void ifThenElse_consumer() {
+    void ifThenElse_void() {
         MockedConsumer<Integer> intConsumer = new MockedConsumer<>();
         MockedConsumer<String> strConsumer = new MockedConsumer<>();
         {
-            getOk().ifThenElse(intConsumer, strConsumer);
+            getOk().ifThenElse_void(intConsumer, strConsumer);
             intConsumer.assertCalledOnceWith(314);
             strConsumer.assertNotCalled();
         }
         intConsumer.reset();
         strConsumer.reset();
         {
-            getErr().ifThenElse(intConsumer, strConsumer);
+            getErr().ifThenElse_void(intConsumer, strConsumer);
             intConsumer.assertNotCalled();
             strConsumer.assertCalledOnceWith("TESTING_ERROR");
         }

From b610ef2583cb85fb1462e1c3d0d9f7b718237543 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 22:16:36 +0100
Subject: [PATCH 36/45] refactor: Add okOption, errOption

---
 .../net/marcellperger/mathexpr/util/rs/Result.java   |  6 ++++++
 .../marcellperger/mathexpr/util/rs/ResultTest.java   | 12 ++++++++++++
 2 files changed, 18 insertions(+)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 3873586..dd62b0c 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -68,6 +68,12 @@ static <T, E> Result<T, E> newErr(E err) {
     default Optional<Ok<T, E>> okOpt() { return Optional.ofNullable(ok()); }
     default Optional<Err<T, E>> errOpt() { return Optional.ofNullable(err()); }
 
+    default Option<T> okOption() {
+        return mapOr(Option.newNone(), Option::newSome);
+    }
+    default Option<E> errOption() {
+        return ifThenElse(_ok -> Option.newNone(), Option::newSome);
+    }
 
     default boolean isOk() { return ok() != null; }
     default boolean isErr() { return err() != null; }
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index a401ea6..a1307bd 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -430,4 +430,16 @@ void errOpt() {
         assertEquals(Optional.empty(), getOk().errOpt());
         assertEquals(Optional.of(new Err<>("TESTING_ERROR")), getErr().errOpt());
     }
+
+    @Test
+    void okOption() {
+        assertEquals(Option.newSome(314), getOk().okOption());
+        assertEquals(Option.newNone(), getErr().okOption());
+    }
+
+    @Test
+    void errOption() {
+        assertEquals(Option.newNone(), getOk().errOption());
+        assertEquals(Option.newSome("TESTING_ERROR"), getErr().errOption());
+    }
 }
\ No newline at end of file

From c03d23f5adfdffd394ee95f829335de0cbe00592 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 22:27:17 +0100
Subject: [PATCH 37/45] refactor: Add Option.ofOptional, Option.ofNullable

---
 .../net/marcellperger/mathexpr/util/rs/Option.java  | 10 ++++++++++
 .../net/marcellperger/mathexpr/util/rs/Result.java  |  2 --
 .../marcellperger/mathexpr/util/rs/OptionTest.java  | 13 +++++++++++++
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index 74b69cd..aa6140d 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -3,9 +3,11 @@
 import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Collections;
 import java.util.Iterator;
+import java.util.Optional;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -46,6 +48,14 @@ record None<T>() implements Option<T> {
         return new None<>();
     }
 
+    static <T> Option<@NotNull T> ofNullable(@Nullable T value) {
+        return ofOptional(Optional.ofNullable(value));
+    }
+    @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
+    static <T> Option<T> ofOptional(Optional<T> value) {
+        return value.map(Option::newSome).orElse(newNone());
+    }
+
     default boolean isSome() {
         return this instanceof Some<T>;
     }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index dd62b0c..715b3dd 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -91,8 +91,6 @@ default boolean isErrAnd(Predicate<? super E> f)  {
         };
     }
 
-    // TODO: once Option is done, do proper ok() / err() -> Option<T / E>
-
     default <U> Result<U, E> map(Function<? super T, ? extends U> op) {
         return switch (this) {
             case Ok(T value) -> new Ok<>(op.apply(value));
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index c3f3e68..10fe2af 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -6,6 +6,7 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Optional;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -343,4 +344,16 @@ void test_toString() {
         assertEquals("Some(314)", getSome().toString());
         assertEquals("None", getNone().toString());
     }
+
+    @Test
+    void ofOptional() {
+        assertEquals(Option.newSome(314), Option.ofOptional(Optional.of(314)));
+        assertEquals(Option.newNone(), Option.ofOptional(Optional.empty()));
+    }
+
+    @Test
+    void ofNullable() {
+        assertEquals(Option.newSome(314), Option.ofNullable(314));
+        assertEquals(Option.newNone(), Option.ofNullable(null));
+    }
 }
\ No newline at end of file

From 75e0bb3efa40b3207230d15d749005c3fde7fc14 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 25 May 2024 22:36:42 +0100
Subject: [PATCH 38/45] refactor: Make Mocked* more concise

---
 .../net/marcellperger/mathexpr/MiniMock.java  | 59 +++----------------
 1 file changed, 7 insertions(+), 52 deletions(-)

diff --git a/src/test/java/net/marcellperger/mathexpr/MiniMock.java b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
index e6fb583..d53f34d 100644
--- a/src/test/java/net/marcellperger/mathexpr/MiniMock.java
+++ b/src/test/java/net/marcellperger/mathexpr/MiniMock.java
@@ -4,6 +4,7 @@
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Unmodifiable;
+import org.junit.jupiter.api.Assertions;
 
 import java.util.*;
 import java.util.function.Consumer;
@@ -11,13 +12,7 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
-import org.junit.jupiter.api.Assertions;
-
 public class MiniMock {
-    enum ReturnStrategy {
-        VALUE, FUNC
-    }
-
     public static class BaseMockedCallable<A> {
         List<A> calls;
 
@@ -42,97 +37,57 @@ public void reset() {
         }
     }
 
-    // TODO there is SO much shared code between these Mocked* classes
     public static class MockedSupplier<R> extends BaseMockedCallable<VoidVal> implements Supplier<R> {
-        // Option<T> would be so useful right now
-        R returnValue;
         Supplier<R> returnSupplier;
-        ReturnStrategy returnStrategy;
 
         public MockedSupplier(R returnValue_) {
-            calls = new ZST_List();
-            returnValue = returnValue_;
-            returnStrategy = ReturnStrategy.VALUE;
+            this(() -> returnValue_);
         }
         public MockedSupplier(Supplier<R> returnSupplier_) {
             calls = new ZST_List();
             returnSupplier = returnSupplier_;
-            returnStrategy = ReturnStrategy.FUNC;
-        }
-
-        protected R getReturn() {
-            return switch (returnStrategy) {
-                case VALUE -> returnValue;
-                case FUNC -> returnSupplier.get();
-            };
         }
 
         @Override
         public R get() {
             handleCall(VoidVal.val());
-            return getReturn();
+            return returnSupplier.get();
         }
     }
 
     public static class MockedFunction<T, R> extends BaseMockedCallable<T> implements Function<T, R> {
-        // Option<T> would be so useful right now
-        R returnValue;
         Function<? super T, ? extends R> returnFunc;
-        ReturnStrategy returnStrategy;
 
         public MockedFunction(R returnValue_) {
-            calls = new ArrayList<>();
-            returnValue = returnValue_;
-            returnStrategy = ReturnStrategy.VALUE;
+            this((_v) -> returnValue_);
         }
         public MockedFunction(Function<? super T, ? extends R> returnSupplier_) {
             calls = new ArrayList<>();
             returnFunc = returnSupplier_;
-            returnStrategy = ReturnStrategy.FUNC;
-        }
-
-        protected R getReturn(T arg) {
-            return switch (returnStrategy) {
-                case VALUE -> returnValue;
-                case FUNC -> returnFunc.apply(arg);
-            };
         }
 
         @Override
         public R apply(T arg) {
             handleCall(arg);
-            return getReturn(arg);
+            return returnFunc.apply(arg);
         }
     }
 
     public static class MockedPredicate<T> extends BaseMockedCallable<T> implements Predicate<T> {
-        // Option<T> would be so useful right now
-        boolean returnValue;
         Predicate<? super T> returnFunc;
-        ReturnStrategy returnStrategy;
 
         public MockedPredicate(boolean returnValue_) {
-            calls = new ArrayList<>();
-            returnValue = returnValue_;
-            returnStrategy = ReturnStrategy.VALUE;
+            this((_v) -> returnValue_);
         }
         public MockedPredicate(Predicate<? super T> returnSupplier_) {
             calls = new ArrayList<>();
             returnFunc = returnSupplier_;
-            returnStrategy = ReturnStrategy.FUNC;
-        }
-
-        protected boolean getReturn(T arg) {
-            return switch (returnStrategy) {
-                case VALUE -> returnValue;
-                case FUNC -> returnFunc.test(arg);
-            };
         }
 
         @Override
         public boolean test(T arg) {
             handleCall(arg);
-            return getReturn(arg);
+            return returnFunc.test(arg);
         }
     }
 

From ae7b7cd0326ff0a4308838d2d39ee49a9bd2dcbe Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 26 May 2024 16:35:53 +0100
Subject: [PATCH 39/45] refactor: Add Result.fromTry

(May or may not involve tricking the compiler)
---
 .../mathexpr/util/ThrowingSupplier.java       |  6 +++
 .../net/marcellperger/mathexpr/util/Util.java | 24 ++++++++++++
 .../mathexpr/util/rs/Result.java              | 14 +++++++
 .../mathexpr/util/rs/ResultTest.java          | 37 +++++++++++++++++++
 4 files changed, 81 insertions(+)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/ThrowingSupplier.java

diff --git a/src/main/java/net/marcellperger/mathexpr/util/ThrowingSupplier.java b/src/main/java/net/marcellperger/mathexpr/util/ThrowingSupplier.java
new file mode 100644
index 0000000..a4f378f
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/ThrowingSupplier.java
@@ -0,0 +1,6 @@
+package net.marcellperger.mathexpr.util;
+
+@FunctionalInterface
+public interface ThrowingSupplier<T, E extends Throwable> {
+    T get() throws E;
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index 41d26d0..0e8ffe2 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -257,4 +257,28 @@ public void forEachRemaining(Consumer<? super T> action) {
             return VoidVal.val();
         };
     }
+
+    // These 2 trick Java into throwing checked exceptions in an unchecked way
+    @Contract("_ -> fail")
+    public static <T> T throwAsUnchecked(Throwable exc) {
+        throwAs(exc);  // <RuntimeException> is inferred from no `throws` clause
+        // Java doesn't know that this always throws so this lets us
+        // do `return/throw throwAsUnchecked()` to make Java's flow control analyser happy
+        throw new AssertionError("Unreachable");
+    }
+    @SuppressWarnings("unchecked")
+    @Contract("_ -> fail")
+    public static <E extends Throwable> void throwAs(Throwable exc) throws E {
+        // We do a little type erasure hack to trick Java:
+        //  - E will be type-erased to Throwable so this will become
+        //       throw (Throwable)exc;
+        //     but exc is already Throwable due to the param type so
+        //     this is like a runtime no-op.
+        //  - But javac will see that we're throwing an E which is allowed!
+        //  - The reason we need a separate method is so that there is a
+        //     generic for javac to type-erase (otherwise JVM would check that
+        //     it's actually that concrete type when it is thrown and this way
+        //     it only checks for the base condition)
+        throw (E)exc;
+    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 715b3dd..d98b723 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -1,5 +1,6 @@
 package net.marcellperger.mathexpr.util.rs;
 
+import net.marcellperger.mathexpr.util.ThrowingSupplier;
 import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -51,6 +52,19 @@ static <T, E> Result<T, E> newErr(E err) {
         return new Err<>(err);
     }
 
+    static <T, E extends Throwable> Result<T, E> fromTry(ThrowingSupplier<? extends T, E> inner, Class<E> catchThis) {
+        try {
+            return newOk(inner.get());
+        } catch (Throwable exc) {
+            try {
+                return newErr(catchThis.cast(exc));
+            } catch (ClassCastException c) {
+                // We've handled E, so only unchecked exceptions should reach here
+                // so it's safe to throw them (but Java doesn't know that so we trick it)
+                return Util.throwAsUnchecked(exc);
+            }
+        }
+    }
 
     default @Nullable Ok<T, E> ok() {
         return switch (this) {
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index a1307bd..32063fa 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -442,4 +442,41 @@ void errOption() {
         assertEquals(Option.newNone(), getOk().errOption());
         assertEquals(Option.newSome("TESTING_ERROR"), getErr().errOption());
     }
+
+    @SuppressWarnings("CommentedOutCode")
+    @Test
+    void fromTry() {
+        assertEquals(Result.newOk(314), Result.fromTry(() -> 314, CustomException.class));
+        CustomException ce = new CustomException("Unchecked (expected) exception");
+        CheckedCustomException cce = new CheckedCustomException("Checked (expected) exception");
+        assertEquals(Result.newErr(cce), Result.fromTry(() -> {throw cce;}, CheckedCustomException.class));
+        assertEquals(Result.newErr(ce), Result.fromTry(() -> {throw ce;}, CustomException.class));
+        UnexpectedCustomException uce = new UnexpectedCustomException("Unexpected unchecked exc");
+        assertThrows(UnexpectedCustomException.class, () -> Result.fromTry(() -> {throw uce;}, CustomException.class));
+        // This doesn't compile so GOOD! (How do I write a test that something DOESN'T compile???)
+        // UnexpectedCheckedCustomException ucc = new UnexpectedCheckedCustomException("Unexpected checked exc");
+        // assertThrows(UnexpectedCheckedCustomException.class, () -> Result.fromTry(() -> {throw ucc;}, CheckedCustomException.class));
+    }
+
+    static class UnexpectedCustomException extends RuntimeException {
+        public UnexpectedCustomException(String message) {
+            super(message);
+        }
+    }
+    static class CustomException extends RuntimeException {
+        public CustomException(String message) {
+            super(message);
+        }
+    }
+    static class CheckedCustomException extends Exception {
+        public CheckedCustomException(String message) {
+            super(message);
+        }
+    }
+    @SuppressWarnings("unused")  // used in the does-not-compile test
+    static class UnexpectedCheckedCustomException extends Exception {
+        public UnexpectedCheckedCustomException(String message) {
+            super(message);
+        }
+    }
 }
\ No newline at end of file

From 2d7883199535452883e8e4faa8fbad87b36e05ba Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 26 May 2024 22:36:52 +0100
Subject: [PATCH 40/45] refactor: Add Result.fromExc, 'fix' coverage

---
 .../util/JacocoIgnoreNotGenerated.java        |  4 ++
 .../mathexpr/util/rs/Result.java              | 28 +++++++++---
 .../mathexpr/util/rs/ResultTest.java          | 45 ++++++++++++++++---
 3 files changed, 65 insertions(+), 12 deletions(-)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/util/JacocoIgnoreNotGenerated.java

diff --git a/src/main/java/net/marcellperger/mathexpr/util/JacocoIgnoreNotGenerated.java b/src/main/java/net/marcellperger/mathexpr/util/JacocoIgnoreNotGenerated.java
new file mode 100644
index 0000000..be5ece3
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/util/JacocoIgnoreNotGenerated.java
@@ -0,0 +1,4 @@
+package net.marcellperger.mathexpr.util;
+
+public @interface JacocoIgnoreNotGenerated {
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index d98b723..7e0ef29 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -1,5 +1,6 @@
 package net.marcellperger.mathexpr.util.rs;
 
+import net.marcellperger.mathexpr.util.JacocoIgnoreNotGenerated;
 import net.marcellperger.mathexpr.util.ThrowingSupplier;
 import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.NotNull;
@@ -52,17 +53,30 @@ static <T, E> Result<T, E> newErr(E err) {
         return new Err<>(err);
     }
 
+    /** Same as fromExc but also fills in the stack trace using
+     * {@link Throwable#fillInStackTrace()} for more useful error messages */
+    static <T, E extends Throwable> @NotNull Result<T, E> fromExc(@NotNull E exc) {
+        exc.fillInStackTrace();
+        return newErr(exc);
+    }
+
     static <T, E extends Throwable> Result<T, E> fromTry(ThrowingSupplier<? extends T, E> inner, Class<E> catchThis) {
         try {
             return newOk(inner.get());
         } catch (Throwable exc) {
-            try {
-                return newErr(catchThis.cast(exc));
-            } catch (ClassCastException c) {
-                // We've handled E, so only unchecked exceptions should reach here
-                // so it's safe to throw them (but Java doesn't know that so we trick it)
-                return Util.throwAsUnchecked(exc);
-            }
+            return _makeErrTypeOrFailUnchecked(exc, catchThis);
+        }
+    }
+
+    @NotNull
+    @JacocoIgnoreNotGenerated
+    private static <T, E extends Throwable> Result<T, E> _makeErrTypeOrFailUnchecked(Throwable exc, Class<E> catchThis) {
+        try {
+            return newErr(catchThis.cast(exc));
+        } catch (ClassCastException c) {
+            // We've handled E, so only unchecked exceptions should reach here
+            // so it's safe to throw them (but Java doesn't know that so we trick it)
+            return Util.throwAsUnchecked(exc);  // Jacoco doesn't realize that the `return` is unreachable
         }
     }
 
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index 32063fa..faf4a13 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -4,10 +4,7 @@
 import net.marcellperger.mathexpr.util.rs.Result.Ok;
 import org.junit.jupiter.api.Test;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 
 import static net.marcellperger.mathexpr.MiniMock.*;
 import static org.junit.jupiter.api.Assertions.*;
@@ -479,4 +476,42 @@ public UnexpectedCheckedCustomException(String message) {
             super(message);
         }
     }
-}
\ No newline at end of file
+
+    @Test
+    void fromExc() {
+        CheckedCustomException cce = new CheckedCustomException("Message");
+        Result<Object, CheckedCustomException> result = inner0(cce);
+        CheckedCustomException cceOut = result.expectErr("fromExc() didn't return Err value");
+        assertEquals(cce, cceOut);
+
+        StackTraceElement currFrame = getCurrentStack();
+        List<StackTraceElement> st = Arrays.stream(cceOut.getStackTrace())
+            .filter(f -> f.getClassName().equals(currFrame.getClassName()))
+            .filter(f -> Objects.equals(f.getFileName(), currFrame.getFileName()))
+            .filter(f -> Objects.equals(f.getModuleName(), currFrame.getModuleName()))
+            .filter(f -> Objects.equals(f.getModuleVersion(), currFrame.getModuleVersion()))
+            .filter(f -> Objects.equals(f.getClassLoaderName(), currFrame.getClassLoaderName()))
+            .toList();
+        List<StackTraceElement> i0 = st.stream()
+            .filter(f -> f.getMethodName().equals("inner0"))
+            .toList();
+        assertEquals(1, i0.size(), "Expected exactly 1 inner0 frame");
+        List<StackTraceElement> i1 = st.stream()
+            .filter(f -> f.getMethodName().equals("inner0"))
+            .toList();
+        assertEquals(1, i1.size(), "Expected exactly 1 inner1 frame");
+    }
+
+    private StackTraceElement getCurrentStack() {
+        return StackWalker.getInstance()
+            .walk(s -> /*Skip this methods*/s.skip(1).findFirst())
+            .orElseThrow().toStackTraceElement();
+    }
+
+    private Result<Object, CheckedCustomException> inner0(CheckedCustomException exc) {
+        return inner1(exc);
+    }
+    private Result<Object, CheckedCustomException> inner1(CheckedCustomException exc) {
+        return Result.fromExc(exc);
+    }
+}

From 23c8da5b2cea72a319c495eeeac748377b8a95c1 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 26 May 2024 22:50:43 +0100
Subject: [PATCH 41/45] refactor: Start using Result in Parser
 (parseDoubleLiteral_result) [WIP]

---
 .../marcellperger/mathexpr/parser/Parser.java   | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
index 8a77708..37d6adc 100644
--- a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
+++ b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
@@ -3,6 +3,7 @@
 import net.marcellperger.mathexpr.*;
 import net.marcellperger.mathexpr.util.Pair;
 import net.marcellperger.mathexpr.util.Util;
+import net.marcellperger.mathexpr.util.rs.Result;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Range;
@@ -62,6 +63,22 @@ public MathSymbol parseExpr() throws ExprParseException {
         }
         return new BasicDoubleSymbol(value);
     }
+    public @NotNull Result<MathSymbol, Throwable> parseDoubleLiteral_result() {
+        discardWhitespace();
+        Matcher m = DOUBLE_RE.matcher(strFromHere());
+        if (!m.lookingAt()) return Result.fromExc(new ExprParseException("Invalid number"));
+        String s = m.group();
+        idx += s.length();
+        double value;
+        try {
+            value = Double.parseDouble(s);
+        } catch (NumberFormatException exc) {
+            // Technically this should never happen - assuming I've got that regex right
+            throw new AssertionError(
+                "There is a problem with the regex, this should've been rejected earlier", exc);
+        }
+        return Result.newOk(new BasicDoubleSymbol(value));
+    }
 
     public @Nullable MathSymbol parseParensOrLiteral() throws ExprParseException {
         discardWhitespace();

From 332a5fc04ad893c9e3f97e427691afeed9a2a94d Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Mon, 27 May 2024 20:11:30 +0100
Subject: [PATCH 42/45] refactor: More progress on converting to Result

---
 .../marcellperger/mathexpr/parser/Parser.java | 115 +++++++++++++++---
 .../mathexpr/util/rs/Result.java              |   7 ++
 2 files changed, 107 insertions(+), 15 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
index 37d6adc..495a375 100644
--- a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
+++ b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
@@ -3,6 +3,8 @@
 import net.marcellperger.mathexpr.*;
 import net.marcellperger.mathexpr.util.Pair;
 import net.marcellperger.mathexpr.util.Util;
+import net.marcellperger.mathexpr.util.VoidVal;
+import net.marcellperger.mathexpr.util.rs.Option;
 import net.marcellperger.mathexpr.util.rs.Result;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -12,7 +14,10 @@
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import java.util.function.Function;
+import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -37,6 +42,14 @@ public MathSymbol parse() throws ExprParseException {
     public MathSymbol parseExpr() throws ExprParseException {
         return parseInfixPrecedenceLevel(SymbolInfo.MAX_PRECEDENCE);
     }
+    public Result<MathSymbol, ExprParseException> parseExpr_result() {
+        // TODO do this better
+        try {
+            return Result.newOk(parseInfixPrecedenceLevel(SymbolInfo.MAX_PRECEDENCE));
+        } catch (ExprParseException e) {
+            return Result.newErr(e);
+        }
+    }
 
     // https://regex101.com/r/2EogTA/1
     protected static final Pattern DOUBLE_RE = Pattern.compile("^([+-]?)(\\d*\\.\\d+|\\d+\\.?)(?:[eE]([+-]?\\d+))?");
@@ -63,21 +76,27 @@ public MathSymbol parseExpr() throws ExprParseException {
         }
         return new BasicDoubleSymbol(value);
     }
-    public @NotNull Result<MathSymbol, Throwable> parseDoubleLiteral_result() {
+    public @NotNull Result<MathSymbol, ExprParseException> parseDoubleLiteral_result() {
         discardWhitespace();
-        Matcher m = DOUBLE_RE.matcher(strFromHere());
-        if (!m.lookingAt()) return Result.fromExc(new ExprParseException("Invalid number"));
-        String s = m.group();
-        idx += s.length();
-        double value;
-        try {
-            value = Double.parseDouble(s);
-        } catch (NumberFormatException exc) {
-            // Technically this should never happen - assuming I've got that regex right
-            throw new AssertionError(
-                "There is a problem with the regex, this should've been rejected earlier", exc);
-        }
-        return Result.newOk(new BasicDoubleSymbol(value));
+        return matchNextRegexString(DOUBLE_RE, "Invalid number").andThen(s -> {
+            try {
+                return Result.newOk(new BasicDoubleSymbol(Double.parseDouble(s)));
+            } catch (NumberFormatException exc) {
+                throw new AssertionError("There is a problem with the regex," +
+                    " this should've been rejected earlier", exc);
+            }
+        });
+    }
+
+    public @NotNull Result<MathSymbol, ExprParseException> parseParensOrLiteral_result() {
+        discardWhitespace();
+        return peek() == '(' ? parseParens_result() : parseDoubleLiteral_result();
+    }
+
+    public @NotNull Result<MathSymbol, ExprParseException> parseParens_result() {
+        return advanceExpectNext_ignoreWs_result('(')
+            .andThen(_c -> parseExpr_result())
+            .runIfOk(_sym -> advanceExpectNext_ignoreWs_result(')'));
     }
 
     public @Nullable MathSymbol parseParensOrLiteral() throws ExprParseException {
@@ -95,6 +114,24 @@ public MathSymbol parseExpr() throws ExprParseException {
         return sym;
     }
 
+//    public Result<MathSymbol, ExprParseException> parseInfixPrecedenceLevel_result(int level) {
+//        discardWhitespace();
+//        if(level == 0) return parseParensOrLiteral_result();
+//        PrecedenceLevelInfo precInfo = SymbolInfo.PREC_LEVELS_INFO.get(level);
+//        if (precInfo == null) return parseInfixPrecedenceLevel_result(level - 1);  // fallthrough empty levels
+//        return parseInfixPrecedenceLevel_result(level - 1).andThen(left -> switch (precInfo.dirn) {
+//            case LeftToRight -> parseInfixPrecedenceLevel_LTR(left, precInfo);
+//            case RightToLeft -> parseInfixPrecedenceLevel_RTL(left, precInfo);
+//            case null -> parseInfixPrecedenceLevel_noDirn(left, precInfo);
+//        });
+////        MathSymbol left = parseInfixPrecedenceLevel(level - 1);
+////        return switch (precInfo.dirn) {
+////            case LeftToRight -> parseInfixPrecedenceLevel_LTR(left, precInfo);
+////            case RightToLeft -> parseInfixPrecedenceLevel_RTL(left, precInfo);
+////            case null -> parseInfixPrecedenceLevel_noDirn(left, precInfo);
+////        };
+//    }
+
     public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException {
         discardWhitespace();
         if(level == 0) return parseParensOrLiteral();
@@ -108,6 +145,22 @@ public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException
         };
     }
 
+    private Result<MathSymbol, ExprParseException> parseInfixPrecedenceLevel_RTL_result(MathSymbol left, PrecedenceLevelInfo precInfo) {
+        return Result.fromTry(() -> {
+            String op;
+            List<Pair<SymbolInfo, MathSymbol>> otherOps = new ArrayList<>();
+            while((op = discardMatchesNextAny_optionsSorted_removeWs(precInfo.sortedInfixes)) != null) {
+                otherOps.add(new Pair<>(
+                    Util.getNotNull(precInfo.infixToSymbolMap, op),
+                    parseInfixPrecedenceLevel(precInfo.precedence - 1)));
+            }
+            return otherOps.reversed().stream().reduce((rightpair, leftpair) ->
+                leftpair.asVars((preOp, argL) ->
+                    new Pair<>(preOp, rightpair.asVars((midOp, argR) -> BinaryOperation.construct(argL, midOp, argR))))
+            ).map(p -> p.asVars((midOp, argR) -> BinaryOperation.construct(left, midOp, argR))).orElse(left);
+        }, ExprParseException.class);
+    }
+
     private MathSymbol parseInfixPrecedenceLevel_RTL(MathSymbol left, PrecedenceLevelInfo precInfo) throws ExprParseException {
         String op;
         List<Pair<SymbolInfo, MathSymbol>> otherOps = new ArrayList<>();
@@ -192,11 +245,43 @@ protected void advanceExpectNext_ignoreWs(char expected) {
         discardWhitespace();
         advanceExpectNext(expected);
     }
+    protected Result<Character, ExprParseException> advanceExpectNext_ignoreWs_result(char expected) {
+        discardWhitespace();
+        return advanceExpectNext_result(expected);
+    }
+    protected Result<Character, ExprParseException> advanceExpectNext_result(char expected) {
+        char actual = advance();
+        if (actual == expected) return Result.newOk(actual);
+        return Result.newErr(new ExprParseException("Expected '%c', got '%c'".formatted(expected, actual)));
+    }
+
+    protected Result<MatchResult, ExprParseException> matchNextRegexResult(@NotNull Pattern pat, ExprParseException exc) {
+        Matcher m = pat.matcher(strFromHere());
+        if (!m.lookingAt()) return Result.fromExc(exc);
+        String s = m.group();
+        idx += s.length();
+        return Result.newOk(m.toMatchResult());
+    }
+    protected Result<MatchResult, ExprParseException> matchNextRegexResult(@NotNull Pattern pat, String exc) {
+        return matchNextRegexResult(pat, new ExprParseException(exc));
+    }
+    protected Result<MatchResult, ExprParseException> matchNextRegexResult(@NotNull Pattern pat) {
+        return matchNextRegexResult(pat, "Regex should've been matched");
+    }
+    protected Result<String, ExprParseException> matchNextRegexString(@NotNull Pattern pat, ExprParseException exc) {
+        return matchNextRegexResult(pat, exc).map(MatchResult::group);
+    }
+    protected Result<String, ExprParseException> matchNextRegexString(@NotNull Pattern pat, String msg) {
+        return matchNextRegexResult(pat, msg).map(MatchResult::group);
+    }
+    protected Result<String, ExprParseException> matchNextRegexString(@NotNull Pattern pat) {
+        return matchNextRegexResult(pat).map(MatchResult::group);
+    }
 
     protected boolean matchesNext(@NotNull String expected) {
         return src.startsWith(expected, /*start*/idx);
     }
-    
+
     private @NotNull List<@NotNull String> sortedByLength(@NotNull List<@NotNull String> arr) {
         return arr.stream().sorted(Comparator.comparingInt(String::length).reversed()).toList();
     }
diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
index 7e0ef29..c0d73cb 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Result.java
@@ -158,6 +158,13 @@ default Result<T, E> inspectErr(Consumer<? super E> f) {
         return mapErr(Util.consumerToIdentityFunc(f));
     }
 
+    default Result<T, E> runIfOk(Consumer<? super T> f) {
+        return map(Util.consumerToIdentityFunc(f));
+    }
+    default Result<T, E> runIfErr(Consumer<? super E> f) {
+        return mapErr(Util.consumerToIdentityFunc(f));
+    }
+
     // .iter()-esque methods: why does Java have SO MANY - one is enough.
     default Stream<T> stream() {
         return okOpt().map(Ok::value).stream();

From 38540de988001f1ae96ec2db20d36bab1d1f1129 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Mon, 27 May 2024 20:36:34 +0100
Subject: [PATCH 43/45] refactor: Convert back to checked exceptions

Checked exceptions are much more ergonomic has they have first-class language support and syntax, unlike my Result type.
---
 .../marcellperger/mathexpr/parser/Parser.java | 143 ++++--------------
 1 file changed, 26 insertions(+), 117 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
index 495a375..7c9ac2b 100644
--- a/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
+++ b/src/main/java/net/marcellperger/mathexpr/parser/Parser.java
@@ -3,9 +3,6 @@
 import net.marcellperger.mathexpr.*;
 import net.marcellperger.mathexpr.util.Pair;
 import net.marcellperger.mathexpr.util.Util;
-import net.marcellperger.mathexpr.util.VoidVal;
-import net.marcellperger.mathexpr.util.rs.Option;
-import net.marcellperger.mathexpr.util.rs.Result;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Range;
@@ -14,8 +11,6 @@
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
-import java.util.Map;
-import java.util.Objects;
 import java.util.function.Function;
 import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
@@ -42,96 +37,32 @@ public MathSymbol parse() throws ExprParseException {
     public MathSymbol parseExpr() throws ExprParseException {
         return parseInfixPrecedenceLevel(SymbolInfo.MAX_PRECEDENCE);
     }
-    public Result<MathSymbol, ExprParseException> parseExpr_result() {
-        // TODO do this better
-        try {
-            return Result.newOk(parseInfixPrecedenceLevel(SymbolInfo.MAX_PRECEDENCE));
-        } catch (ExprParseException e) {
-            return Result.newErr(e);
-        }
-    }
 
     // https://regex101.com/r/2EogTA/1
     protected static final Pattern DOUBLE_RE = Pattern.compile("^([+-]?)(\\d*\\.\\d+|\\d+\\.?)(?:[eE]([+-]?\\d+))?");
-    @SuppressWarnings("unused")  // ignore for now - will fix later with the better error handling
-    public @NotNull MathSymbol parseDoubleLiteral_exc() throws ExprParseException {
-        return switch (parseDoubleLiteral_null()) {
-            case null -> throw new ExprParseException("Couldn't parse double in expression");
-            case MathSymbol sym -> sym;
-        };
-    }
-    public @Nullable MathSymbol parseDoubleLiteral_null() {
+    public @NotNull MathSymbol parseDoubleLiteral() throws ExprParseException {
         discardWhitespace();
-        Matcher m = DOUBLE_RE.matcher(strFromHere());
-        if (!m.lookingAt()) return null;
-        String s = m.group();
-        idx += s.length();
-        double value;
+        String s = matchNextRegexString(DOUBLE_RE, "Invalid number (double)");
         try {
-            value = Double.parseDouble(s);
-        } catch (NumberFormatException _exc) {
-            // Technically this should never happen - assuming I've got that regex right
-            assert false: "There is a problem with the regex, this should've been rejected earlier";
-            return null;
+            return new BasicDoubleSymbol(Double.parseDouble(s));
+        } catch (NumberFormatException exc) {
+            throw new AssertionError("There is a problem with the regex," +
+                " this should've been rejected earlier", exc);
         }
-        return new BasicDoubleSymbol(value);
-    }
-    public @NotNull Result<MathSymbol, ExprParseException> parseDoubleLiteral_result() {
-        discardWhitespace();
-        return matchNextRegexString(DOUBLE_RE, "Invalid number").andThen(s -> {
-            try {
-                return Result.newOk(new BasicDoubleSymbol(Double.parseDouble(s)));
-            } catch (NumberFormatException exc) {
-                throw new AssertionError("There is a problem with the regex," +
-                    " this should've been rejected earlier", exc);
-            }
-        });
     }
 
-    public @NotNull Result<MathSymbol, ExprParseException> parseParensOrLiteral_result() {
+    public @NotNull MathSymbol parseParensOrLiteral() throws ExprParseException {
         discardWhitespace();
-        return peek() == '(' ? parseParens_result() : parseDoubleLiteral_result();
+        return peek() == '(' ? parseParens() : parseDoubleLiteral();
     }
 
-    public @NotNull Result<MathSymbol, ExprParseException> parseParens_result() {
-        return advanceExpectNext_ignoreWs_result('(')
-            .andThen(_c -> parseExpr_result())
-            .runIfOk(_sym -> advanceExpectNext_ignoreWs_result(')'));
-    }
-
-    public @Nullable MathSymbol parseParensOrLiteral() throws ExprParseException {
-        discardWhitespace();
-        if(peek() == '(') return parseParens();
-        // TODO add a better error handling system - don't want to maintain 2 versions of each function
-        //  returning null: +easier to do unions, +no need for verbose try/catch, -no info about errors
-        return parseDoubleLiteral_null();
-    }
-
-    public @Nullable MathSymbol parseParens() throws ExprParseException {
+    public MathSymbol parseParens() throws ExprParseException {
         advanceExpectNext_ignoreWs('(');
         MathSymbol sym = parseExpr();
         advanceExpectNext_ignoreWs(')');
         return sym;
     }
 
-//    public Result<MathSymbol, ExprParseException> parseInfixPrecedenceLevel_result(int level) {
-//        discardWhitespace();
-//        if(level == 0) return parseParensOrLiteral_result();
-//        PrecedenceLevelInfo precInfo = SymbolInfo.PREC_LEVELS_INFO.get(level);
-//        if (precInfo == null) return parseInfixPrecedenceLevel_result(level - 1);  // fallthrough empty levels
-//        return parseInfixPrecedenceLevel_result(level - 1).andThen(left -> switch (precInfo.dirn) {
-//            case LeftToRight -> parseInfixPrecedenceLevel_LTR(left, precInfo);
-//            case RightToLeft -> parseInfixPrecedenceLevel_RTL(left, precInfo);
-//            case null -> parseInfixPrecedenceLevel_noDirn(left, precInfo);
-//        });
-////        MathSymbol left = parseInfixPrecedenceLevel(level - 1);
-////        return switch (precInfo.dirn) {
-////            case LeftToRight -> parseInfixPrecedenceLevel_LTR(left, precInfo);
-////            case RightToLeft -> parseInfixPrecedenceLevel_RTL(left, precInfo);
-////            case null -> parseInfixPrecedenceLevel_noDirn(left, precInfo);
-////        };
-//    }
-
     public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException {
         discardWhitespace();
         if(level == 0) return parseParensOrLiteral();
@@ -145,22 +76,6 @@ public MathSymbol parseInfixPrecedenceLevel(int level) throws ExprParseException
         };
     }
 
-    private Result<MathSymbol, ExprParseException> parseInfixPrecedenceLevel_RTL_result(MathSymbol left, PrecedenceLevelInfo precInfo) {
-        return Result.fromTry(() -> {
-            String op;
-            List<Pair<SymbolInfo, MathSymbol>> otherOps = new ArrayList<>();
-            while((op = discardMatchesNextAny_optionsSorted_removeWs(precInfo.sortedInfixes)) != null) {
-                otherOps.add(new Pair<>(
-                    Util.getNotNull(precInfo.infixToSymbolMap, op),
-                    parseInfixPrecedenceLevel(precInfo.precedence - 1)));
-            }
-            return otherOps.reversed().stream().reduce((rightpair, leftpair) ->
-                leftpair.asVars((preOp, argL) ->
-                    new Pair<>(preOp, rightpair.asVars((midOp, argR) -> BinaryOperation.construct(argL, midOp, argR))))
-            ).map(p -> p.asVars((midOp, argR) -> BinaryOperation.construct(left, midOp, argR))).orElse(left);
-        }, ExprParseException.class);
-    }
-
     private MathSymbol parseInfixPrecedenceLevel_RTL(MathSymbol left, PrecedenceLevelInfo precInfo) throws ExprParseException {
         String op;
         List<Pair<SymbolInfo, MathSymbol>> otherOps = new ArrayList<>();
@@ -237,45 +152,39 @@ protected void discardWhitespace() {
         advanceWhile(Character::isWhitespace);
     }
 
-    protected void advanceExpectNext(char expected) {
+    protected void advanceExpectNext(char expected) throws ExprParseException {
         char actual = advance();
-        if(actual != expected) throw new ExprParseRtException("Expected '%c', got '%c'".formatted(expected, actual));
+        if(actual != expected) throw new ExprParseException("Expected '%c', got '%c'".formatted(expected, actual));
     }
-    protected void advanceExpectNext_ignoreWs(char expected) {
+    protected void advanceExpectNext_ignoreWs(char expected) throws ExprParseException {
         discardWhitespace();
         advanceExpectNext(expected);
     }
-    protected Result<Character, ExprParseException> advanceExpectNext_ignoreWs_result(char expected) {
-        discardWhitespace();
-        return advanceExpectNext_result(expected);
-    }
-    protected Result<Character, ExprParseException> advanceExpectNext_result(char expected) {
-        char actual = advance();
-        if (actual == expected) return Result.newOk(actual);
-        return Result.newErr(new ExprParseException("Expected '%c', got '%c'".formatted(expected, actual)));
-    }
 
-    protected Result<MatchResult, ExprParseException> matchNextRegexResult(@NotNull Pattern pat, ExprParseException exc) {
+    protected MatchResult matchNextRegexResult(@NotNull Pattern pat, ExprParseException exc) throws ExprParseException {
         Matcher m = pat.matcher(strFromHere());
-        if (!m.lookingAt()) return Result.fromExc(exc);
+        if (!m.lookingAt()) throw exc;
         String s = m.group();
         idx += s.length();
-        return Result.newOk(m.toMatchResult());
+        return m.toMatchResult();
     }
-    protected Result<MatchResult, ExprParseException> matchNextRegexResult(@NotNull Pattern pat, String exc) {
+    protected MatchResult matchNextRegexResult(@NotNull Pattern pat, String exc) throws ExprParseException {
         return matchNextRegexResult(pat, new ExprParseException(exc));
     }
-    protected Result<MatchResult, ExprParseException> matchNextRegexResult(@NotNull Pattern pat) {
+    protected MatchResult matchNextRegexResult(@NotNull Pattern pat) throws ExprParseException {
         return matchNextRegexResult(pat, "Regex should've been matched");
     }
-    protected Result<String, ExprParseException> matchNextRegexString(@NotNull Pattern pat, ExprParseException exc) {
-        return matchNextRegexResult(pat, exc).map(MatchResult::group);
+    @SuppressWarnings("unused")
+    protected String matchNextRegexString(@NotNull Pattern pat, ExprParseException exc) throws ExprParseException {
+        return matchNextRegexResult(pat, exc).group();
     }
-    protected Result<String, ExprParseException> matchNextRegexString(@NotNull Pattern pat, String msg) {
-        return matchNextRegexResult(pat, msg).map(MatchResult::group);
+    @SuppressWarnings("SameParameterValue")
+    protected String matchNextRegexString(@NotNull Pattern pat, String msg) throws ExprParseException {
+        return matchNextRegexResult(pat, msg).group();
     }
-    protected Result<String, ExprParseException> matchNextRegexString(@NotNull Pattern pat) {
-        return matchNextRegexResult(pat).map(MatchResult::group);
+    @SuppressWarnings("unused")
+    protected String matchNextRegexString(@NotNull Pattern pat) throws ExprParseException {
+        return matchNextRegexResult(pat).group();
     }
 
     protected boolean matchesNext(@NotNull String expected) {

From 9b02b60b0605ade52d175070ab31b6d989c1b0ec Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Mon, 27 May 2024 20:43:28 +0100
Subject: [PATCH 44/45] test: Add tests for the extra 2 methods on Result

---
 .../mathexpr/util/rs/ResultTest.java          | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
index faf4a13..023c88d 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/ResultTest.java
@@ -176,6 +176,26 @@ void inspectErr() {
         strCons.assertNotCalled();
     }
 
+    @Test
+    void runIfOk() {
+        MockedConsumer<Integer> intCons = new MockedConsumer<>();
+        assertEquals(getOk(), getOk().runIfOk(intCons));
+        intCons.assertCalledOnceWith(314);
+        intCons.reset();
+        assertEquals(getErr(), getErr().runIfOk(intCons));
+        intCons.assertNotCalled();
+    }
+
+    @Test
+    void runIfErr() {
+        MockedConsumer<String> strCons = new MockedConsumer<>();
+        assertEquals(getErr(), getErr().runIfErr(strCons));
+        strCons.assertCalledOnceWith("TESTING_ERROR");
+        strCons.reset();
+        assertEquals(getOk(), getOk().runIfErr(strCons));
+        strCons.assertNotCalled();
+    }
+
     @Test
     void stream() {
         assertEquals(List.of(314), getOk().stream().toList());

From a62a01ae3a19c36f268f80348b33e6dfdf8d4eb4 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Mon, 27 May 2024 20:47:11 +0100
Subject: [PATCH 45/45] refactor: Remove old ExprParseRtException.java (we're
 using checked exceptions)

---
 .../mathexpr/parser/ExprParseRtException.java | 20 -------------------
 1 file changed, 20 deletions(-)
 delete mode 100644 src/main/java/net/marcellperger/mathexpr/parser/ExprParseRtException.java

diff --git a/src/main/java/net/marcellperger/mathexpr/parser/ExprParseRtException.java b/src/main/java/net/marcellperger/mathexpr/parser/ExprParseRtException.java
deleted file mode 100644
index 1b4c25a..0000000
--- a/src/main/java/net/marcellperger/mathexpr/parser/ExprParseRtException.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package net.marcellperger.mathexpr.parser;
-
-@SuppressWarnings("unused")  // I want all the constructors!
-public class ExprParseRtException extends RuntimeException {
-    public ExprParseRtException() {
-        super();
-    }
-
-    public ExprParseRtException(String message) {
-        super(message);
-    }
-
-    public ExprParseRtException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public ExprParseRtException(Throwable cause) {
-        super(cause);
-    }
-}