code: public OptionalDouble foldLeft(DoubleBinaryOperator accumulator) {
          PrimitiveBox b = new PrimitiveBox();
          forEachOrdered(t -> {
              if (b.b)
                  b.d = accumulator.applyAsDouble(b.d, t);
              else {
                  b.d = t;
                  b.b = true;
              }
          });
          return b.asDouble();
      }
docs: Folds the elements of this stream using the provided accumulation
  function, going left to right. This is equivalent to:
  
  <pre>
  {@code
  boolean foundAny = false;
  double result = 0;
  for (double element : this stream) {
  if (!foundAny) {
  foundAny = true;
  result = element;
  }
  else
  result = accumulator.apply(result, element);
  }
  return foundAny ? OptionalDouble.of(result) : OptionalDouble.empty();
  }
  </pre>
  
  <p>
  This is a terminal operation.
  
  <p>
  This method cannot take all the advantages of parallel streams as it must
  process elements strictly left to right. If your accumulator function is
  associative, consider using {@link #reduce(DoubleBinaryOperator)} method.
  
  <p>
  For parallel stream it's not guaranteed that accumulator will always be
  executed in the same thread.
  
  @param accumulator a
  <a href="package-summary.html#NonInterference">non-interfering
  </a>, <a href="package-summary.html#Statelessness">stateless</a>
  function for incorporating an additional element into a result
  @return the result of the folding
  @see #foldLeft(double, DoubleBinaryOperator)
  @see #reduce(DoubleBinaryOperator)
  @since 0.4.0