code: public <U> U foldRight(U seed, BiFunction<? super T, U, U> accumulator) {
          return toListAndThen(list -> {
              U result = seed;
              for (int i = list.size() - 1; i >= 0; i--)
                  result = accumulator.apply(list.get(i), result);
              return result;
          });
      }
docs: Folds the elements of this stream using the provided seed object and
  accumulation function, going right to left.
  
  <p>
  This is a terminal operation.
  
  <p>
  As this method must process elements strictly right to left, it cannot
  start processing till all the previous stream stages complete. Also it
  requires intermediate memory to store the whole content of the stream as
  the stream natural order is 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 #foldLeft(Object, BiFunction)
  @see #reduce(Object, BinaryOperator)
  @see #reduce(Object, BiFunction, BinaryOperator)
  @since 0.2.2