code: public <U> U foldLeft(U seed, BiFunction<U, ? super T, U> accumulator) {
          Box<U> result = new Box<>(seed);
          forEachOrdered(t -> result.a = accumulator.apply(result.a, t));
          return result.a;
      }
docs: Folds the elements of this stream using the provided seed object and
  accumulation function, going left to right. This is equivalent to:
  
  <pre>
  {@code
  U result = seed;
  for (T element : this stream)
  result = accumulator.apply(result, element)
  return result;
  }
  </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 and you can provide a combiner function, consider using
  {@link #reduce(Object, BiFunction, BinaryOperator)} method.
  
  <p>
  For parallel stream it's not guaranteed that accumulator will always be
  executed in the same thread.
  
  @param <U> The type of the result
  @param seed the starting value
  @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 #foldRight(Object, BiFunction)
  @see #reduce(Object, BinaryOperator)
  @see #reduce(Object, BiFunction, BinaryOperator)
  @since 0.2.0