forEachLazily(IntStream, IntConsumer)

Author: fluentfuture

mug/src/main/java/com/google/mu/util/stream/Iteration.java

@@ -24,7 +24,9 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
+import java.util.function.IntConsumer;
 import java.util.function.Supplier;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 /**
@@ -267,6 +269,16 @@ public final <V> Iteration<T> forEachLazily(Stream<V> stream, Consumer<? super V
     return forEachLazily(stream.spliterator(), consumer);
   }
 
+  /**
+   * Applies {@code consumer} lazily on each int element from {@code stream}.
+   * An element is only iterated when consumed by the result stream.
+   *
+   * @since 9.6
+   */
+  public final <V> Iteration<T> forEachLazily(IntStream stream, IntConsumer consumer) {
+    return forEachLazily(stream.spliterator(), consumer);
+  }
+
   /**
    * Applies {@code consumer} lazily on each element from {@code spliterator}.
    * An element is only iterated when consumed by the result stream.
@@ -285,6 +297,24 @@ public final <V> Iteration<T> forEachLazily(
             }));
   }
 
+  /**
+   * Applies {@code consumer} lazily on each int element from {@code spliterator}.
+   * An element is only iterated when consumed by the result stream.
+   *
+   * @since 9.6
+   */
+  public final <V> Iteration<T> forEachLazily(
+      Spliterator.OfInt spliterator, IntConsumer consumer) {
+    requireNonNull(spliterator);
+    requireNonNull(consumer);
+    return lazily(
+        () -> spliterator.tryAdvance(
+            (int i) -> {
+              consumer.accept(i);
+              forEachLazily(spliterator, consumer);
+            }));
+  }
+
   /**
    * Applies {@code consumer} lazily on each entry from {@code map}.
    * An entry is only iterated when consumed by the result stream.

mug/src/test/java/com/google/mu/util/stream/IterationTest.java

@@ -19,6 +19,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import org.junit.Test;
@@ -42,6 +43,13 @@ public class IterationTest {
         .inOrder();
   }
 
+  @Test public void emit_lazyIntElements() {
+    Iteration<Integer> iteration = new Iteration<>();
+    assertThat(iteration.forEachLazily(IntStream.of(1, 2, 3), iteration::emit).iterate())
+        .containsExactly(1, 2, 3)
+        .inOrder();
+  }
+
   @Test public void emit_lazyEntries() {
     Iteration<String> iteration = new Iteration<>();
     assertThat(iteration.forEachLazily(

mug/src/test/java/com/google/mu/util/stream/PermutationTest.java

@@ -46,7 +46,7 @@ void next(List<T> buffer, int i) {
         }
         lazily(() -> next(buffer, i + 1));
         forEachLazily(
-            IntStream.range(i + 1, buffer.size()).boxed(),
+            IntStream.range(i + 1, buffer.size()),
             j -> {
               swap(buffer, i, j);
               next(buffer, i + 1);