com.aol.cyclops.reactor

Class MonoTs

java.lang.Object

com.aol.cyclops.reactor.MonoTs

public class MonoTs
extends java.lang.Object

Companion class for working with MonoTransformers

Constructor Summary

Constructors

Constructor and Description
MonoTs()

Method Summary

Modifier and Type	Method and Description
static <T> AnyMSeq<T>	anyM(MonoT<T> mono) Construct an AnyM type from a Mono.
static <T,R1,R> MonoT<R>	forEach(MonoT<? extends T> value1, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a MonoT, accepting a generating function.
static <T,R1,R> MonoT<R>	forEach(MonoT<? extends T> value1, java.util.function.Function<? super T,org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a MonoT, accepting a generating function.
static <T1,T2,R1,R2,R> MonoT<R>	forEach3(MonoT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a MonoT, accepting 2 generating functions.
static <T1,T2,R1,R2,R> MonoT<R>	forEach3(MonoT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction, TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a MonoT, accepting 2 generating functions.
static <T1,T2,T3,R1,R2,R3,R> MonoT<R>	forEach4(MonoT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<R3>> value4, QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a MonoT, accepting 3 generating functions.
static <T1,T2,T3,R1,R2,R3,R> MonoT<R>	forEach4(MonoT<? extends T1> value1, java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3, TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<R3>> value4, QuadFunction<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a MonoT, accepting 3 generating functions.
static <T> MonoTSeq<T>	monoT(org.reactivestreams.Publisher<reactor.core.publisher.Mono<T>> nested) Construct a MonoT from a Publisher containing Monos.

Methods inherited from class java.lang.Object

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

Constructor Detail

MonoTs

public MonoTs()

Method Detail

anyM

public static <T> AnyMSeq<T> anyM(MonoT<T> mono)

Construct an AnyM type from a Mono. This allows the Mono to be manipulated according to a standard interface along with a vast array of other Java Monad implementations

  
    
    AnyMSeq<Integer> mono = Fluxes.anyM(Mono.just(1,2,3));
    AnyMSeq<Integer> transformedMono = myGenericOperation(mono);
    
    public AnyMSeq<Integer> myGenericOperation(AnyMSeq<Integer> monad);
 
 

Parameters:

mono - To wrap inside an AnyM

Returns:

AnyMSeq wrapping a Mono

monoT

public static <T> MonoTSeq<T> monoT(org.reactivestreams.Publisher<reactor.core.publisher.Mono<T>> nested)

Construct a MonoT from a Publisher containing Monos.

Parameters:

nested - Publisher of Monos

Returns:

Mono Transformer for manipulating nested Monos

forEach4

public static <T1,T2,T3,R1,R2,R3,R> MonoT<R> forEach4(MonoT<? extends T1> value1,
                                                      java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                      java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                      TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<R3>> value4,
                                                      QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a MonoT, accepting 3 generating functions. This results in a four level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.MonoTs.forEach4;
   
    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
         forEach4(monoT, 
                  a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                  (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                  (a,b,c)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
               Tuple::tuple)
               .forEach(System.out::println);
               
     //(10, 10, 10, 10)
       (11, 11, 11, 11)
       (100, 100, 100, 100)
       (101, 101, 101, 101)        
 
 
 

Parameters:

value1 - top level MonoT

value2 - Nested publisher

value3 - Nested publisher

value4 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

MonoTSeq with an element per combination of nested publishers generated by the yielding function

forEach4

public static <T1,T2,T3,R1,R2,R3,R> MonoT<R> forEach4(MonoT<? extends T1> value1,
                                                      java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                      java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                      TriFunction<? super T1,? super R1,? super R2,? extends org.reactivestreams.Publisher<R3>> value4,
                                                      QuadFunction<? super T1,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
                                                      QuadFunction<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

Perform a For Comprehension over a MonoT, accepting 3 generating functions. This results in a four level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.MonoTs.forEach4;
   
    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach4(monoT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c,d)->a+b+c+d<102,
              Tuple::tuple)
              .forEach(System.out::println);
              
    //(10, 10, 10, 10)
      (11, 11, 11, 11)       
 
 
 

Parameters:

value1 - top level MonoT

value2 - Nested publisher

value3 - Nested publisher

value4 - Nested publisher

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

forEach3

public static <T1,T2,R1,R2,R> MonoT<R> forEach3(MonoT<? extends T1> value1,
                                                java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a MonoT, accepting 2 generating functions. This results in three level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.MonoTs.forEach3;
   
    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach3(monoT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
              Tuple::tuple)
              .forEach(System.out::println);
              
         
 
 
 

Parameters:

value1 - top level MonoT

value2 - Nested publisher

value3 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

MonoTSeq with an element per combination of nested publishers generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> MonoT<R> forEach3(MonoT<? extends T1> value1,
                                                java.util.function.Function<? super T1,? extends org.reactivestreams.Publisher<R1>> value2,
                                                java.util.function.BiFunction<? super T1,? super R1,? extends org.reactivestreams.Publisher<R2>> value3,
                                                TriFunction<? super T1,? super R1,? super R2,java.lang.Boolean> filterFunction,
                                                TriFunction<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

Perform a For Comprehension over a MonoT, accepting 2 generating functions. This results in a three level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.MonoTs.forEach3;
   
    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach3(monoT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b)-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c,d)->a+b+c+d<102,
              Tuple::tuple)
              .forEach(System.out::println);
    
 
 
 

Parameters:

value1 - top level MonoT

value2 - Nested publisher

value3 - Nested publisher

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

MonoTSeq with an element per combination of nested publishers generated by the yielding function

forEach

public static <T,R1,R> MonoT<R> forEach(MonoT<? extends T> value1,
                                        java.util.function.Function<? super T,org.reactivestreams.Publisher<R1>> value2,
                                        java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a MonoT, accepting a generating function. This results in two level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.MonoTs.forEach;
   
    MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
       forEach(monoT, 
                a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
             Tuple::tuple)
             .forEach(System.out::println);
             
        
 
 
 

Parameters:

value1 - top level MonoT

value2 - Nested publisher

value3 - Nested publisher

yieldingFunction - Generates a result per combination

Returns:

MonoTSeq with an element per combination of nested publishers generated by the yielding function

forEach

public static <T,R1,R> MonoT<R> forEach(MonoT<? extends T> value1,
                                        java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<R1>> value2,
                                        java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
                                        java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

Perform a For Comprehension over a MonoT, accepting a generating function. This results in a two level nested internal iteration over the provided Publishers.

 
    
   import static com.aol.cyclops.reactor.MonoTs.forEach;
   
   MonoT<Integer> monoT = MonoT.fromIterable(Arrays.asList(Flux.range(10,2),Flux.range(100,2)));
    
        forEach(monoT, 
                 a-> ReactiveSeq.iterate(a,i->i+1).limit(2),
                 (a,b,c,d)->a+b+c+d<102,
              Tuple::tuple)
              .forEach(System.out::println);
    
 
 
 

Parameters:

value1 - top level MonoT

value2 - Nested publisher

value3 - Nested publisher

filterFunction - A filtering function, keeps values where the predicate holds

yieldingFunction - Generates a result per combination

Returns:

MonoTSeq with an element per combination of nested publishers generated by the yielding function