code: @SuppressWarnings({ "rawtypes", "unchecked" })
      public static <TUPLE extends Tuple2, V> Flux<V> zip(Publisher<? extends
  			Publisher<?>> sources,
  			final Function<? super TUPLE, ? extends V> combinator) {
  
  		return onAssembly(new FluxBuffer<>(from(sources), Integer.MAX_VALUE, listSupplier())
  		                    .flatMap(new Function<List<? extends Publisher<?>>, Publisher<V>>() {
  			                    @Override
  			                    public Publisher<V> apply(List<? extends Publisher<?>> publishers) {
  				                    return zip(Tuples.fnAny((Function<Tuple2, V>)
  						                    combinator), publishers.toArray(new Publisher[publishers
  						                    .size()]));
  			                    }
  		                    }));
  	}
docs: Zip multiple sources together, that is to say wait for all the sources to emit one
  element and combine these elements once into an output value (constructed by the provided
  combinator).
  The operator will continue doing so until any of the sources completes.
  Errors will immediately be forwarded.
  This "Step-Merge" processing is especially useful in Scatter-Gather scenarios.
  <p>
  Note that the {@link Publisher} sources from the outer {@link Publisher} will
  accumulate into an exhaustive list before starting zip operation.
  <p>
  <img class="marble" src="doc-files/marbles/zipAsyncSourcesForFlux.svg" alt="">
  
  @param sources The {@link Publisher} of {@link Publisher} sources to zip. A finite publisher is required.
  @param combinator The aggregate function that will receive a unique value from each upstream and return the value
  to signal downstream
  @param <TUPLE> the raw tuple type
  @param <V> The produced output after transformation by the given combinator
  
  @return a {@link Flux} based on the produced value