Module life.expert

Package life.expert.common.reactivestreams

Class ForComprehension

java.lang.Object

life.expert.common.reactivestreams.ForComprehension

public final class ForComprehension
extends java.lang.Object

 auxiliary static functions with arguments - several Function

 - functional for-comprehension pattern for reactive flows
 - required to convert a null value returned by a function to an empty flow event
 - at the first null value returned, the chain of nested calls stops

 1) first group of functions,like For(flux,func1,func) take result of func1 and put in on the input fo func2

      flux=>result1
      func1(result1)=>result2
      func2(result2)=>output result (as Publisher)

      A shortcut for  ts.flatMap(f) which allows us to write real for-comprehensions using  For(...).yield(...).
         For(getPersons(), person ->
                For(person.getTweets(), tweet ->
                        For(tweet.getReplies())
                                .yield(reply -> person + ", " + tweet + ", " + reply)));

      or For(getPersons(),getTweets(),getReplies())


 2) second group of functions, like For(flux1,flux2).yield(func)
    A shortcut for  flux1.flatMap( i->flux2.map(j->func(i,j)) )   what means
        for i
              for j
                   func(i,j)

     For( range( 1 , 3 ) , range( 1 , 3 ) ).yield( logAtInfoBiFunction("") )
                                       .subscribe();


 

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ForComprehension.FluxFor1<T1>	For-comprehension with one Flux.
static class	ForComprehension.FluxFor2<T1,T2>	For-comprehension with two Fluxs.
static class	ForComprehension.FluxFor3<T1,T2,T3>	For-comprehension with three Fluxs.
static class	ForComprehension.FluxFor4<T1,T2,T3,T4>	For-comprehension with 4 Fluxs.
static class	ForComprehension.FluxFor5<T1,T2,T3,T4,T5>	For-comprehension with 5 Fluxs.
static class	ForComprehension.FluxFor6<T1,T2,T3,T4,T5,T6>	For-comprehension with 6 Fluxs.
static class	ForComprehension.FluxFor7<T1,T2,T3,T4,T5,T6,T7>	For-comprehension with 7 Fluxs.
static class	ForComprehension.FluxFor8<T1,T2,T3,T4,T5,T6,T7,T8>	For-comprehension with 8 Fluxs.
static class	ForComprehension.MonoFor1<T1>	For-comprehension with one Mono.
static class	ForComprehension.MonoFor2<T1,T2>	For-comprehension with two Monos.
static class	ForComprehension.MonoFor3<T1,T2,T3>	For-comprehension with three Monos.
static class	ForComprehension.MonoFor4<T1,T2,T3,T4>	For-comprehension with 4 Monos.
static class	ForComprehension.MonoFor5<T1,T2,T3,T4,T5>	For-comprehension with 5 Monos.
static class	ForComprehension.MonoFor6<T1,T2,T3,T4,T5,T6>	For-comprehension with 6 Monos.
static class	ForComprehension.MonoFor7<T1,T2,T3,T4,T5,T6,T7>	For-comprehension with 7 Monos.
static class	ForComprehension.MonoFor8<T1,T2,T3,T4,T5,T6,T7,T8>	For-comprehension with 8 Monos.

Constructor Summary

Constructors

Constructor	Description
ForComprehension()

Method Summary

Modifier and Type	Method	Description
static <T1> ForComprehension.FluxFor1<T1>	For(reactor.core.publisher.Flux<T1> ts1)	Creates a For-comprehension of one Flux.
static <T1,T2> org.reactivestreams.Publisher<T2>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2)	For publisher.
static <T1,T2,T3> org.reactivestreams.Publisher<T3>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3)	For publisher.
static <T1,T2,T3,T4> org.reactivestreams.Publisher<T4>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4)	For publisher.
static <T1,T2,T3,T4,T5> org.reactivestreams.Publisher<T5>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5)	For publisher.
static <T1,T2,T3,T4,T5,T6> org.reactivestreams.Publisher<T6>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5, java.util.function.Function<? super reactor.core.publisher.Flux<T5>,? extends org.reactivestreams.Publisher<T6>> ts6)	For publisher.
static <T1,T2,T3,T4,T5,T6,T7> org.reactivestreams.Publisher<T7>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5, java.util.function.Function<? super reactor.core.publisher.Flux<T5>,? extends org.reactivestreams.Publisher<T6>> ts6, java.util.function.Function<? super reactor.core.publisher.Flux<T6>,? extends org.reactivestreams.Publisher<T7>> ts7)	For publisher.
static <T1,T2,T3,T4,T5,T6,T7,T8> org.reactivestreams.Publisher<T8>	For(reactor.core.publisher.Flux<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5, java.util.function.Function<? super reactor.core.publisher.Flux<T5>,? extends org.reactivestreams.Publisher<T6>> ts6, java.util.function.Function<? super reactor.core.publisher.Flux<T6>,? extends org.reactivestreams.Publisher<T7>> ts7, java.util.function.Function<? super reactor.core.publisher.Flux<T7>,? extends org.reactivestreams.Publisher<T8>> ts8)	For publisher.
static <T1,T2> ForComprehension.FluxFor2<T1,T2>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2)	Creates a For-comprehension of two Fluxs.
static <T1,T2,T3> ForComprehension.FluxFor3<T1,T2,T3>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2, reactor.core.publisher.Flux<T3> ts3)	Creates a For-comprehension of three Fluxs.
static <T1,T2,T3,T4> ForComprehension.FluxFor4<T1,T2,T3,T4>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2, reactor.core.publisher.Flux<T3> ts3, reactor.core.publisher.Flux<T4> ts4)	Creates a For-comprehension of 4 Fluxs.
static <T1,T2,T3,T4,T5> ForComprehension.FluxFor5<T1,T2,T3,T4,T5>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2, reactor.core.publisher.Flux<T3> ts3, reactor.core.publisher.Flux<T4> ts4, reactor.core.publisher.Flux<T5> ts5)	Creates a For-comprehension of 5 Fluxs.
static <T1,T2,T3,T4,T5,T6> ForComprehension.FluxFor6<T1,T2,T3,T4,T5,T6>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2, reactor.core.publisher.Flux<T3> ts3, reactor.core.publisher.Flux<T4> ts4, reactor.core.publisher.Flux<T5> ts5, reactor.core.publisher.Flux<T6> ts6)	Creates a For-comprehension of 6 Fluxs.
static <T1,T2,T3,T4,T5,T6,T7> ForComprehension.FluxFor7<T1,T2,T3,T4,T5,T6,T7>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2, reactor.core.publisher.Flux<T3> ts3, reactor.core.publisher.Flux<T4> ts4, reactor.core.publisher.Flux<T5> ts5, reactor.core.publisher.Flux<T6> ts6, reactor.core.publisher.Flux<T7> ts7)	Creates a For-comprehension of 7 Fluxs.
static <T1,T2,T3,T4,T5,T6,T7,T8> ForComprehension.FluxFor8<T1,T2,T3,T4,T5,T6,T7,T8>	For(reactor.core.publisher.Flux<T1> ts1, reactor.core.publisher.Flux<T2> ts2, reactor.core.publisher.Flux<T3> ts3, reactor.core.publisher.Flux<T4> ts4, reactor.core.publisher.Flux<T5> ts5, reactor.core.publisher.Flux<T6> ts6, reactor.core.publisher.Flux<T7> ts7, reactor.core.publisher.Flux<T8> ts8)	Creates a For-comprehension of 8 Fluxs.
static <T1> ForComprehension.MonoFor1<T1>	For(reactor.core.publisher.Mono<T1> ts1)	Creates a For-comprehension of one Mono.
static <T1,T2> reactor.core.publisher.Mono<T2>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2)	For mono.
static <T1,T2,T3> reactor.core.publisher.Mono<T3>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3)	For mono.
static <T1,T2,T3,T4> reactor.core.publisher.Mono<T4>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4)	For mono.
static <T1,T2,T3,T4,T5> reactor.core.publisher.Mono<T5>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5)	For mono.
static <T1,T2,T3,T4,T5,T6> reactor.core.publisher.Mono<T6>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5, java.util.function.Function<? super reactor.core.publisher.Mono<T5>,? extends reactor.core.publisher.Mono<T6>> ts6)	For mono.
static <T1,T2,T3,T4,T5,T6,T7> reactor.core.publisher.Mono<T7>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5, java.util.function.Function<? super reactor.core.publisher.Mono<T5>,? extends reactor.core.publisher.Mono<T6>> ts6, java.util.function.Function<? super reactor.core.publisher.Mono<T6>,? extends reactor.core.publisher.Mono<T7>> ts7)	For mono.
static <T1,T2,T3,T4,T5,T6,T7,T8> reactor.core.publisher.Mono<T8>	For(reactor.core.publisher.Mono<T1> ts1, java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2, java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3, java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4, java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5, java.util.function.Function<? super reactor.core.publisher.Mono<T5>,? extends reactor.core.publisher.Mono<T6>> ts6, java.util.function.Function<? super reactor.core.publisher.Mono<T6>,? extends reactor.core.publisher.Mono<T7>> ts7, java.util.function.Function<? super reactor.core.publisher.Mono<T7>,? extends reactor.core.publisher.Mono<T8>> ts8)	For mono.
static <T1,T2> ForComprehension.MonoFor2<T1,T2>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2)	Creates a For-comprehension of two Monos.
static <T1,T2,T3> ForComprehension.MonoFor3<T1,T2,T3>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2, reactor.core.publisher.Mono<T3> ts3)	Creates a For-comprehension of three Monos.
static <T1,T2,T3,T4> ForComprehension.MonoFor4<T1,T2,T3,T4>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2, reactor.core.publisher.Mono<T3> ts3, reactor.core.publisher.Mono<T4> ts4)	Creates a For-comprehension of 4 Monos.
static <T1,T2,T3,T4,T5> ForComprehension.MonoFor5<T1,T2,T3,T4,T5>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2, reactor.core.publisher.Mono<T3> ts3, reactor.core.publisher.Mono<T4> ts4, reactor.core.publisher.Mono<T5> ts5)	Creates a For-comprehension of 5 Monos.
static <T1,T2,T3,T4,T5,T6> ForComprehension.MonoFor6<T1,T2,T3,T4,T5,T6>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2, reactor.core.publisher.Mono<T3> ts3, reactor.core.publisher.Mono<T4> ts4, reactor.core.publisher.Mono<T5> ts5, reactor.core.publisher.Mono<T6> ts6)	Creates a For-comprehension of 6 Monos.
static <T1,T2,T3,T4,T5,T6,T7> ForComprehension.MonoFor7<T1,T2,T3,T4,T5,T6,T7>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2, reactor.core.publisher.Mono<T3> ts3, reactor.core.publisher.Mono<T4> ts4, reactor.core.publisher.Mono<T5> ts5, reactor.core.publisher.Mono<T6> ts6, reactor.core.publisher.Mono<T7> ts7)	Creates a For-comprehension of 7 Monos.
static <T1,T2,T3,T4,T5,T6,T7,T8> ForComprehension.MonoFor8<T1,T2,T3,T4,T5,T6,T7,T8>	For(reactor.core.publisher.Mono<T1> ts1, reactor.core.publisher.Mono<T2> ts2, reactor.core.publisher.Mono<T3> ts3, reactor.core.publisher.Mono<T4> ts4, reactor.core.publisher.Mono<T5> ts5, reactor.core.publisher.Mono<T6> ts6, reactor.core.publisher.Mono<T7> ts7, reactor.core.publisher.Mono<T8> ts8)	Creates a For-comprehension of 8 Monos.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ForComprehension

public ForComprehension()

Method Detail

For

public static <T1,T2> org.reactivestreams.Publisher<T2> For(reactor.core.publisher.Flux<T1> ts1,
                                                                  java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

Returns:

the publisher

For

public static <T1,T2> reactor.core.publisher.Mono<T2> For(reactor.core.publisher.Mono<T1> ts1,
                                                                java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

Returns:

the mono

For

public static <T1,T2,T3> org.reactivestreams.Publisher<T3> For(reactor.core.publisher.Flux<T1> ts1,
                                                                           java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2,
                                                                           java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

Returns:

the publisher

For

public static <T1,T2,T3> reactor.core.publisher.Mono<T3> For(reactor.core.publisher.Mono<T1> ts1,
                                                                         java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2,
                                                                         java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

Returns:

the mono

For

public static <T1,T2,T3,T4> org.reactivestreams.Publisher<T4> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                    java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2,
                                                                                    java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3,
                                                                                    java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

Returns:

the publisher

For

public static <T1,T2,T3,T4> reactor.core.publisher.Mono<T4> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                  java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2,
                                                                                  java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3,
                                                                                  java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

Returns:

the mono

For

public static <T1,T2,T3,T4,T5> org.reactivestreams.Publisher<T5> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                             java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2,
                                                                                             java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3,
                                                                                             java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4,
                                                                                             java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

Returns:

the publisher

For

public static <T1,T2,T3,T4,T5> reactor.core.publisher.Mono<T5> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                           java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2,
                                                                                           java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3,
                                                                                           java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4,
                                                                                           java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

Returns:

the mono

For

public static <T1,T2,T3,T4,T5,T6> org.reactivestreams.Publisher<T6> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                      java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2,
                                                                                                      java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3,
                                                                                                      java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4,
                                                                                                      java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5,
                                                                                                      java.util.function.Function<? super reactor.core.publisher.Flux<T5>,? extends org.reactivestreams.Publisher<T6>> ts6)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

T6 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

ts6 - the ts 6

Returns:

the publisher

For

public static <T1,T2,T3,T4,T5,T6> reactor.core.publisher.Mono<T6> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                    java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2,
                                                                                                    java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3,
                                                                                                    java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4,
                                                                                                    java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5,
                                                                                                    java.util.function.Function<? super reactor.core.publisher.Mono<T5>,? extends reactor.core.publisher.Mono<T6>> ts6)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

T6 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

ts6 - the ts 6

Returns:

the mono

For

public static <T1,T2,T3,T4,T5,T6,T7> org.reactivestreams.Publisher<T7> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                               java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2,
                                                                                                               java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3,
                                                                                                               java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4,
                                                                                                               java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5,
                                                                                                               java.util.function.Function<? super reactor.core.publisher.Flux<T5>,? extends org.reactivestreams.Publisher<T6>> ts6,
                                                                                                               java.util.function.Function<? super reactor.core.publisher.Flux<T6>,? extends org.reactivestreams.Publisher<T7>> ts7)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

T6 - the type parameter

T7 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

ts6 - the ts 6

ts7 - the ts 7

Returns:

the publisher

For

public static <T1,T2,T3,T4,T5,T6,T7> reactor.core.publisher.Mono<T7> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                             java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2,
                                                                                                             java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3,
                                                                                                             java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4,
                                                                                                             java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5,
                                                                                                             java.util.function.Function<? super reactor.core.publisher.Mono<T5>,? extends reactor.core.publisher.Mono<T6>> ts6,
                                                                                                             java.util.function.Function<? super reactor.core.publisher.Mono<T6>,? extends reactor.core.publisher.Mono<T7>> ts7)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

T6 - the type parameter

T7 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

ts6 - the ts 6

ts7 - the ts 7

Returns:

the mono

For

public static <T1,T2,T3,T4,T5,T6,T7,T8> org.reactivestreams.Publisher<T8> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T1>,? extends org.reactivestreams.Publisher<T2>> ts2,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T2>,? extends org.reactivestreams.Publisher<T3>> ts3,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T3>,? extends org.reactivestreams.Publisher<T4>> ts4,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T4>,? extends org.reactivestreams.Publisher<T5>> ts5,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T5>,? extends org.reactivestreams.Publisher<T6>> ts6,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T6>,? extends org.reactivestreams.Publisher<T7>> ts7,
                                                                                                                        java.util.function.Function<? super reactor.core.publisher.Flux<T7>,? extends org.reactivestreams.Publisher<T8>> ts8)

For publisher.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

T6 - the type parameter

T7 - the type parameter

T8 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

ts6 - the ts 6

ts7 - the ts 7

ts8 - the ts 8

Returns:

the publisher

For

public static <T1,T2,T3,T4,T5,T6,T7,T8> reactor.core.publisher.Mono<T8> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T1>,? extends reactor.core.publisher.Mono<T2>> ts2,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T2>,? extends reactor.core.publisher.Mono<T3>> ts3,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T3>,? extends reactor.core.publisher.Mono<T4>> ts4,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T4>,? extends reactor.core.publisher.Mono<T5>> ts5,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T5>,? extends reactor.core.publisher.Mono<T6>> ts6,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T6>,? extends reactor.core.publisher.Mono<T7>> ts7,
                                                                                                                      java.util.function.Function<? super reactor.core.publisher.Mono<T7>,? extends reactor.core.publisher.Mono<T8>> ts8)

For mono.

Type Parameters:

T1 - the type parameter

T2 - the type parameter

T3 - the type parameter

T4 - the type parameter

T5 - the type parameter

T6 - the type parameter

T7 - the type parameter

T8 - the type parameter

Parameters:

ts1 - the ts 1

ts2 - the ts 2

ts3 - the ts 3

ts4 - the ts 4

ts5 - the ts 5

ts6 - the ts 6

ts7 - the ts 7

ts8 - the ts 8

Returns:

the mono

For

public static <T1> ForComprehension.MonoFor1<T1> For(reactor.core.publisher.Mono<T1> ts1)

Creates a For-comprehension of one Mono.

Type Parameters:

T1 - component type of the 1st Mono

Parameters:

ts1 - the 1st Mono

Returns:

a new For-comprehension of arity 1

For

public static <T1,T2> ForComprehension.MonoFor2<T1,T2> For(reactor.core.publisher.Mono<T1> ts1,
                                                                       reactor.core.publisher.Mono<T2> ts2)

Creates a For-comprehension of two Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

Returns:

a new For-comprehension of arity 2

For

public static <T1,T2,T3> ForComprehension.MonoFor3<T1,T2,T3> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                         reactor.core.publisher.Mono<T2> ts2,
                                                                                         reactor.core.publisher.Mono<T3> ts3)

Creates a For-comprehension of three Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

T3 - component type of the 3rd Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

ts3 - the 3rd Mono

Returns:

a new For-comprehension of arity 3

For

public static <T1,T2,T3,T4> ForComprehension.MonoFor4<T1,T2,T3,T4> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                           reactor.core.publisher.Mono<T2> ts2,
                                                                                                           reactor.core.publisher.Mono<T3> ts3,
                                                                                                           reactor.core.publisher.Mono<T4> ts4)

Creates a For-comprehension of 4 Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

T3 - component type of the 3rd Mono

T4 - component type of the 4th Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

ts3 - the 3rd Mono

ts4 - the 4th Mono

Returns:

a new For-comprehension of arity 4

For

public static <T1,T2,T3,T4,T5> ForComprehension.MonoFor5<T1,T2,T3,T4,T5> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                                             reactor.core.publisher.Mono<T2> ts2,
                                                                                                                             reactor.core.publisher.Mono<T3> ts3,
                                                                                                                             reactor.core.publisher.Mono<T4> ts4,
                                                                                                                             reactor.core.publisher.Mono<T5> ts5)

Creates a For-comprehension of 5 Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

T3 - component type of the 3rd Mono

T4 - component type of the 4th Mono

T5 - component type of the 5th Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

ts3 - the 3rd Mono

ts4 - the 4th Mono

ts5 - the 5th Mono

Returns:

a new For-comprehension of arity 5

For

public static <T1,T2,T3,T4,T5,T6> ForComprehension.MonoFor6<T1,T2,T3,T4,T5,T6> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                                                               reactor.core.publisher.Mono<T2> ts2,
                                                                                                                                               reactor.core.publisher.Mono<T3> ts3,
                                                                                                                                               reactor.core.publisher.Mono<T4> ts4,
                                                                                                                                               reactor.core.publisher.Mono<T5> ts5,
                                                                                                                                               reactor.core.publisher.Mono<T6> ts6)

Creates a For-comprehension of 6 Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

T3 - component type of the 3rd Mono

T4 - component type of the 4th Mono

T5 - component type of the 5th Mono

T6 - component type of the 6th Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

ts3 - the 3rd Mono

ts4 - the 4th Mono

ts5 - the 5th Mono

ts6 - the 6th Mono

Returns:

a new For-comprehension of arity 6

For

public static <T1,T2,T3,T4,T5,T6,T7> ForComprehension.MonoFor7<T1,T2,T3,T4,T5,T6,T7> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                                                                                 reactor.core.publisher.Mono<T2> ts2,
                                                                                                                                                                 reactor.core.publisher.Mono<T3> ts3,
                                                                                                                                                                 reactor.core.publisher.Mono<T4> ts4,
                                                                                                                                                                 reactor.core.publisher.Mono<T5> ts5,
                                                                                                                                                                 reactor.core.publisher.Mono<T6> ts6,
                                                                                                                                                                 reactor.core.publisher.Mono<T7> ts7)

Creates a For-comprehension of 7 Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

T3 - component type of the 3rd Mono

T4 - component type of the 4th Mono

T5 - component type of the 5th Mono

T6 - component type of the 6th Mono

T7 - component type of the 7th Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

ts3 - the 3rd Mono

ts4 - the 4th Mono

ts5 - the 5th Mono

ts6 - the 6th Mono

ts7 - the 7th Mono

Returns:

a new For-comprehension of arity 7

For

public static <T1,T2,T3,T4,T5,T6,T7,T8> ForComprehension.MonoFor8<T1,T2,T3,T4,T5,T6,T7,T8> For(reactor.core.publisher.Mono<T1> ts1,
                                                                                                                                                                                   reactor.core.publisher.Mono<T2> ts2,
                                                                                                                                                                                   reactor.core.publisher.Mono<T3> ts3,
                                                                                                                                                                                   reactor.core.publisher.Mono<T4> ts4,
                                                                                                                                                                                   reactor.core.publisher.Mono<T5> ts5,
                                                                                                                                                                                   reactor.core.publisher.Mono<T6> ts6,
                                                                                                                                                                                   reactor.core.publisher.Mono<T7> ts7,
                                                                                                                                                                                   reactor.core.publisher.Mono<T8> ts8)

Creates a For-comprehension of 8 Monos.

Type Parameters:

T1 - component type of the 1st Mono

T2 - component type of the 2nd Mono

T3 - component type of the 3rd Mono

T4 - component type of the 4th Mono

T5 - component type of the 5th Mono

T6 - component type of the 6th Mono

T7 - component type of the 7th Mono

T8 - component type of the 8th Mono

Parameters:

ts1 - the 1st Mono

ts2 - the 2nd Mono

ts3 - the 3rd Mono

ts4 - the 4th Mono

ts5 - the 5th Mono

ts6 - the 6th Mono

ts7 - the 7th Mono

ts8 - the 8th Mono

Returns:

a new For-comprehension of arity 8

For

public static <T1> ForComprehension.FluxFor1<T1> For(reactor.core.publisher.Flux<T1> ts1)

Creates a For-comprehension of one Flux.

Type Parameters:

T1 - component type of the 1st Flux

Parameters:

ts1 - the 1st Flux

Returns:

a new For-comprehension of arity 1

For

public static <T1,T2> ForComprehension.FluxFor2<T1,T2> For(reactor.core.publisher.Flux<T1> ts1,
                                                                       reactor.core.publisher.Flux<T2> ts2)

Creates a For-comprehension of two Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

Returns:

a new For-comprehension of arity 2

For

public static <T1,T2,T3> ForComprehension.FluxFor3<T1,T2,T3> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                         reactor.core.publisher.Flux<T2> ts2,
                                                                                         reactor.core.publisher.Flux<T3> ts3)

Creates a For-comprehension of three Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

T3 - component type of the 3rd Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

ts3 - the 3rd Flux

Returns:

a new For-comprehension of arity 3

For

public static <T1,T2,T3,T4> ForComprehension.FluxFor4<T1,T2,T3,T4> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                           reactor.core.publisher.Flux<T2> ts2,
                                                                                                           reactor.core.publisher.Flux<T3> ts3,
                                                                                                           reactor.core.publisher.Flux<T4> ts4)

Creates a For-comprehension of 4 Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

T3 - component type of the 3rd Flux

T4 - component type of the 4th Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

ts3 - the 3rd Flux

ts4 - the 4th Flux

Returns:

a new For-comprehension of arity 4

For

public static <T1,T2,T3,T4,T5> ForComprehension.FluxFor5<T1,T2,T3,T4,T5> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                                             reactor.core.publisher.Flux<T2> ts2,
                                                                                                                             reactor.core.publisher.Flux<T3> ts3,
                                                                                                                             reactor.core.publisher.Flux<T4> ts4,
                                                                                                                             reactor.core.publisher.Flux<T5> ts5)

Creates a For-comprehension of 5 Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

T3 - component type of the 3rd Flux

T4 - component type of the 4th Flux

T5 - component type of the 5th Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

ts3 - the 3rd Flux

ts4 - the 4th Flux

ts5 - the 5th Flux

Returns:

a new For-comprehension of arity 5

For

public static <T1,T2,T3,T4,T5,T6> ForComprehension.FluxFor6<T1,T2,T3,T4,T5,T6> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                                                               reactor.core.publisher.Flux<T2> ts2,
                                                                                                                                               reactor.core.publisher.Flux<T3> ts3,
                                                                                                                                               reactor.core.publisher.Flux<T4> ts4,
                                                                                                                                               reactor.core.publisher.Flux<T5> ts5,
                                                                                                                                               reactor.core.publisher.Flux<T6> ts6)

Creates a For-comprehension of 6 Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

T3 - component type of the 3rd Flux

T4 - component type of the 4th Flux

T5 - component type of the 5th Flux

T6 - component type of the 6th Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

ts3 - the 3rd Flux

ts4 - the 4th Flux

ts5 - the 5th Flux

ts6 - the 6th Flux

Returns:

a new For-comprehension of arity 6

For

public static <T1,T2,T3,T4,T5,T6,T7> ForComprehension.FluxFor7<T1,T2,T3,T4,T5,T6,T7> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                                                                                 reactor.core.publisher.Flux<T2> ts2,
                                                                                                                                                                 reactor.core.publisher.Flux<T3> ts3,
                                                                                                                                                                 reactor.core.publisher.Flux<T4> ts4,
                                                                                                                                                                 reactor.core.publisher.Flux<T5> ts5,
                                                                                                                                                                 reactor.core.publisher.Flux<T6> ts6,
                                                                                                                                                                 reactor.core.publisher.Flux<T7> ts7)

Creates a For-comprehension of 7 Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

T3 - component type of the 3rd Flux

T4 - component type of the 4th Flux

T5 - component type of the 5th Flux

T6 - component type of the 6th Flux

T7 - component type of the 7th Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

ts3 - the 3rd Flux

ts4 - the 4th Flux

ts5 - the 5th Flux

ts6 - the 6th Flux

ts7 - the 7th Flux

Returns:

a new For-comprehension of arity 7

For

public static <T1,T2,T3,T4,T5,T6,T7,T8> ForComprehension.FluxFor8<T1,T2,T3,T4,T5,T6,T7,T8> For(reactor.core.publisher.Flux<T1> ts1,
                                                                                                                                                                                   reactor.core.publisher.Flux<T2> ts2,
                                                                                                                                                                                   reactor.core.publisher.Flux<T3> ts3,
                                                                                                                                                                                   reactor.core.publisher.Flux<T4> ts4,
                                                                                                                                                                                   reactor.core.publisher.Flux<T5> ts5,
                                                                                                                                                                                   reactor.core.publisher.Flux<T6> ts6,
                                                                                                                                                                                   reactor.core.publisher.Flux<T7> ts7,
                                                                                                                                                                                   reactor.core.publisher.Flux<T8> ts8)

Creates a For-comprehension of 8 Fluxs.

Type Parameters:

T1 - component type of the 1st Flux

T2 - component type of the 2nd Flux

T3 - component type of the 3rd Flux

T4 - component type of the 4th Flux

T5 - component type of the 5th Flux

T6 - component type of the 6th Flux

T7 - component type of the 7th Flux

T8 - component type of the 8th Flux

Parameters:

ts1 - the 1st Flux

ts2 - the 2nd Flux

ts3 - the 3rd Flux

ts4 - the 4th Flux

ts5 - the 5th Flux

ts6 - the 6th Flux

ts7 - the 7th Flux

ts8 - the 8th Flux

Returns:

a new For-comprehension of arity 8