src/java.base/share/classes/java/util/stream/ReduceOps.java

@@ -32,13 +32,17 @@
 import java.util.Spliterator;
 import java.util.concurrent.CountedCompleter;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
 import java.util.function.DoubleBinaryOperator;
+import java.util.function.DoubleConsumer;
 import java.util.function.IntBinaryOperator;
+import java.util.function.IntConsumer;
 import java.util.function.LongBinaryOperator;
+import java.util.function.LongConsumer;
 import java.util.function.ObjDoubleConsumer;
 import java.util.function.ObjIntConsumer;
 import java.util.function.ObjLongConsumer;
 import java.util.function.Supplier;
 

@@ -961,6 +965,137 @@
             }
             // GC spliterator, left and right child
             super.onCompletion(caller);
         }
     }
+
+    static final class FoldLeftWithSeedOp<U, T> extends Box<U> implements Consumer<T> {
+        private final BiFunction<U, ? super T, U> op;
+
+        FoldLeftWithSeedOp(U seed, BiFunction<U, ? super T, U> op) {
+            this.state = seed;
+            this.op = op;
+        }
+
+        @Override
+        public void accept(T t) {
+            state = op.apply(state, t);
+        }
+    }
+
+    static final class FoldLeftOp<T> implements Consumer<T> {
+        private final BinaryOperator<T> op;
+        private T state;
+        private boolean empty = true;
+
+        FoldLeftOp(BinaryOperator<T> op) {
+            this.op = op;
+        }
+
+        @Override
+        public void accept(T t) {
+            if (empty) {
+                state = t;
+                empty = false;
+            } else {
+                state = op.apply(state, t);
+            }
+        }
+
+        Optional<T> get() {
+            return empty ? Optional.empty() : Optional.of(state);
+        }
+    }
+
+    static final class IntFoldLeftOp implements IntConsumer {
+        private final IntBinaryOperator op;
+        private int state;
+        private boolean empty = true;
+
+        IntFoldLeftOp(IntBinaryOperator op) {
+            this.op = op;
+        }
+
+        @Override
+        public void accept(int t) {
+            if (empty) {
+                state = t;
+                empty = false;
+            } else {
+                state = op.applyAsInt(state, t);
+            }
+        }
+
+        OptionalInt get() {
+            return empty ? OptionalInt.empty() : OptionalInt.of(state);
+        }
+
+        int getAsInt() {
+            if (empty) {
+                throw new IllegalStateException();
+            }
+            return state;
+        }
+    }
+
+    static final class LongFoldLeftOp implements LongConsumer {
+        private final LongBinaryOperator op;
+        private long state;
+        private boolean empty = true;
+
+        LongFoldLeftOp(LongBinaryOperator op) {
+            this.op = op;
+        }
+
+        @Override
+        public void accept(long t) {
+            if (empty) {
+                state = t;
+                empty = false;
+            } else {
+                state = op.applyAsLong(state, t);
+            }
+        }
+
+        OptionalLong get() {
+            return empty ? OptionalLong.empty() : OptionalLong.of(state);
+        }
+
+        long getAsLong() {
+            if (empty) {
+                throw new IllegalStateException();
+            }
+            return state;
+        }
+    }
+
+    static final class DoubleFoldLeftOp implements DoubleConsumer {
+        private final DoubleBinaryOperator op;
+        private double state;
+        private boolean empty = true;
+
+        DoubleFoldLeftOp(DoubleBinaryOperator op) {
+            this.op = op;
+        }
+
+        @Override
+        public void accept(double t) {
+            if (empty) {
+                state = t;
+                empty = false;
+            } else {
+                state = op.applyAsDouble(state, t);
+            }
+        }
+
+        OptionalDouble get() {
+            return empty ? OptionalDouble.empty() : OptionalDouble.of(state);
+        }
+
+        double getAsDouble() {
+            if (empty) {
+                throw new IllegalStateException();
+            }
+            return state;
+        }
+    }
 }