reactor-core/src/main/java/reactor/core/publisher/Flux.java
public final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends V>> mapper, int
			concurrency, int prefetch) {
		return flatMap(mapper, false, concurrency, prefetch);
	}
public final <V> Flux<V> flatMap(Function<? super T, ? extends Publisher<? extends V>> mapper, int
			concurrency, int prefetch) {
		return flatMap(mapper, false, concurrency, prefetch);
	}
Transform the elements emitted by this {@link Flux} asynchronously into Publishers,
then flatten these inner publishers into a single {@link Flux} through merging,
which allow them to interleave.
<p>
There are three dimensions to this operator that can be compared with
{@link #flatMapSequential(Function) flatMapSequential} and {@link #concatMap(Function) concatMap}:
<ul>
<li><b>Generation of inners and subscription</b>: this operator is eagerly
subscribing to its inners.</li>
<li><b>Ordering of the flattened values</b>: this operator does not necessarily preserve
original ordering, as inner element are flattened as they arrive.</li>
<li><b>Interleaving</b>: this operator lets values from different inners interleave
(similar to merging the inner sequences).</li>
</ul>
The concurrency argument allows to control how many {@link Publisher} can be
subscribed to and merged in parallel. In turn, that argument shows the size of
the first {@link Subscription#request} to the upstream.
The prefetch argument allows to give an arbitrary prefetch size to the merged
{@link Publisher} (in other words prefetch size means the size of the first
{@link Subscription#request} to the merged {@link Publisher}).

<p>
<img class="marble" src="doc-files/marbles/flatMapWithConcurrencyAndPrefetch.svg" alt="">

@reactor.discard This operator discards elements internally queued for backpressure upon cancellation or error triggered by a data signal.

@param mapper the {@link Function} to transform input sequence into N sequences {@link Publisher}
@param concurrency the maximum number of in-flight inner sequences
@param prefetch the maximum in-flight elements from each inner {@link Publisher} sequence
@param <V> the merged output sequence type

@reactor.errorMode This operator supports {@link #onErrorContinue(BiConsumer) resuming on errors}
in the mapper {@link Function}. Exceptions thrown by the mapper then behave as if
it had mapped the value to an empty publisher. If the mapper does map to a scalar
publisher (an optimization in which the value can be resolved immediately without
subscribing to the publisher, e.g. a {@link Mono#fromCallable(Callable)}) but said
publisher throws, this can be resumed from in the same manner.

@return a merged {@link Flux}