code: public static <T, A, R> Promise<R> reduce(@NotNull Collector<T, A, R> collector, int maxCalls,
  			@NotNull Iterator<Promise<T>> promises) {
  		return reduce(promises, maxCalls, collector.supplier().get(), collector.accumulator(), collector.finisher());
  	}
docs: Allows to asynchronously reduce {@link Iterator} of {@code Promise}s
  into a {@code Promise} with the help of {@link Collector}. You can
  control the amount of concurrently running {@code Promise}.
  <p>
  This method is universal and allows to implement app-specific logic.
  
  @param collector mutable reduction operation that accumulates input
  elements into a mutable result container
  @param maxCalls  max amount of concurrently running {@code Promise}s
  @param promises  {@code Iterable} of {@code Promise}s
  @param <T>       type of input elements for this operation
  @param <A>       mutable accumulation type of the operation
  @param <R>       the result type of the operation
  @return a {@code Promise} which wraps the accumulated result
  of the reduction. If one of the {@code promises} completed exceptionally,
  a {@code Promise} with an exception will be returned.