code: public static <T, A, R> Promise<R> collect(ChannelSupplier<T> supplier,
  			A initialValue, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
  		return Promise.ofCallback(cb ->
  				toCollectorImpl(supplier, initialValue, accumulator, finisher, cb));
  	}
docs: Collects data provided by the {@code supplier} asynchronously and returns a
  promise of accumulated result. This process will be getting values from the
  {@code supplier}, until a promise of {@code null} is returned, which represents
  end of stream.
  <p>
  If {@code get} returns a promise of exception or there was an exception while
  {@code accumulator} accepted values, a promise of {@code exception} will be
  returned and the process will stop.
  
  @param supplier     a {@code ChannelSupplier} which provides data to be collected
  @param initialValue a value which will accumulate the results of accumulator
  @param accumulator  a {@link BiConsumer} which may perform some operations over provided
  by supplier data and accumulates the result to the initialValue
  @param finisher     a {@link Function} which performs the final transformation of the
  accumulated value
  @param <T>          a data type provided by the {@code supplier}
  @param <A>          an intermediate accumulation data type
  @param <R>          a data type of final result of {@code finisher}
  @return a promise of accumulated result, transformed by the {@code finisher}