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

*** 32,44 ****
--- 32,48 ----
  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,966 ****
--- 965,1101 ----
              }
              // 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;
+         }
+     }
  }