refactor: iteration methods on Option

Author: MarcellPerger1

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

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