code: public final <V> Flux<V> concatMapDelayError(Function<? super T, ? extends Publisher<? extends V>> mapper) {
  		return concatMapDelayError(mapper, Queues.XS_BUFFER_SIZE);
  	}
docs: Transform the elements emitted by this {@link Flux} asynchronously into Publishers,
  then flatten these inner publishers into a single {@link Flux}, sequentially and
  preserving order using concatenation.
  <p>
  There are three dimensions to this operator that can be compared with
  {@link #flatMap(Function) flatMap} and {@link #flatMapSequential(Function) flatMapSequential}:
  <ul>
  <li><b>Generation of inners and subscription</b>: this operator waits for one
  inner to complete before generating the next one and subscribing to it.</li>
  <li><b>Ordering of the flattened values</b>: this operator naturally preserves
  the same order as the source elements, concatenating the inners from each source
  element sequentially.</li>
  <li><b>Interleaving</b>: this operator does not let values from different inners
  interleave (concatenation).</li>
  </ul>
  
  <p>
  Errors in the individual publishers will be delayed at the end of the whole concat
  sequence (possibly getting combined into a {@link Exceptions#isMultiple(Throwable) composite}
  if several sources error.
  
  <p>
  <img class="marble" src="doc-files/marbles/concatMap.svg" alt="">
  
  @reactor.discard This operator discards elements it internally queued for backpressure upon cancellation.
  
  @param mapper the function to transform this sequence of T into concatenated sequences of V
  @param <V> the produced concatenated type
  
  @return a concatenated {@link Flux}