refactor: Add more methods on Option (and, or, okOr, filter)

Author: MarcellPerger1

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
 }

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();
+        }
+    }
 }