code: public final <R> Flux<R> concatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper,
  			int prefetch) {
  		return onAssembly(new FluxFlattenIterable<>(this, mapper, prefetch,
  				Queues.get(prefetch)));
  	}
docs: Transform the items emitted by this {@link Flux} into {@link Iterable}, then flatten the emissions from those by
  concatenating them into a single {@link Flux}. The prefetch argument allows to give an arbitrary prefetch size to the merged {@link Iterable}.
  
  <p>
  <img class="marble" src="doc-files/marbles/concatMapIterable.svg" alt="">
  <p>
  Note that unlike {@link #flatMap(Function)} and {@link #concatMap(Function)}, with Iterable there is
  no notion of eager vs lazy inner subscription. The content of the Iterables are all played sequentially.
  Thus {@code flatMapIterable} and {@code concatMapIterable} are equivalent offered as a discoverability
  improvement for users that explore the API with the concat vs flatMap expectation.
  
  @reactor.discard This operator discards elements it internally queued for backpressure upon cancellation.
  
  @param mapper the {@link Function} to transform input sequence into N {@link Iterable}
  @param prefetch the maximum in-flight elements from each inner {@link Iterable} sequence
  @param <R> the merged output sequence type
  
  @return a concatenation of the values from the Iterables obtained from each element in this {@link Flux}