refactor: Add more methods on Option, fix ambiguous method

Author: MarcellPerger1

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
 }

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