cyclops.companion.reactor

Class Monos

java.lang.Object

cyclops.companion.reactor.Monos

public class Monos
extends java.lang.Object

Companion class for working with Reactor Mono types

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Monos.Instances Companion class for creating Type Class instances for working with Monos
static interface	Monos.MonoNested
static interface	Monos.NestedMono

Constructor Summary

Constructors

Constructor and Description
Monos()

Method Summary

Modifier and Type	Method and Description
static <T> reactor.core.publisher.Mono<T>	allOf(reactor.core.publisher.Mono<T>... fts) Wait until all the provided Future's to complete
static <T> Active<ReactorWitness.mono,T>	allTypeclasses(reactor.core.publisher.Mono<T> type)
static <T> AnyMValue<ReactorWitness.mono,T>	anyM(reactor.core.publisher.Mono<T> mono) Construct an AnyM type from a Mono.
static <T> reactor.core.publisher.Mono<T>	anyOf(reactor.core.publisher.Mono<T>... fts) Select the first Mono to complete
static <T1,T2,R> reactor.core.publisher.Mono<R>	combine(reactor.core.publisher.Mono<? extends T1> mono, reactor.core.publisher.Mono<? extends T2> app, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Lazily combine this Mono with the supplied Mono via the supplied BiFunction
static <T1,T2,R> reactor.core.publisher.Mono<R>	combine(reactor.core.publisher.Mono<? extends T1> mono, Value<? extends T2> app, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Lazily combine this Mono with the supplied value via the supplied BiFunction
static <W1,T> Coproduct<W1,ReactorWitness.mono,T>	coproduct(reactor.core.publisher.Mono<T> list, InstanceDefinitions<W1> def1)
static <W1,T> Coproduct<W1,ReactorWitness.mono,T>	coproduct(T value, InstanceDefinitions<W1> def1)
static <R> Either<java.lang.Throwable,R>	either(reactor.core.publisher.Mono<R> either)
static <T> Eval<T>	eval(reactor.core.publisher.Mono<T> opt)
static <T> reactor.core.publisher.Mono<T>	firstSuccess(reactor.core.publisher.Mono<T>... fts) Select the first Future to return with a successful result
static <T,R1,R> reactor.core.publisher.Mono<R>	forEach(reactor.core.publisher.Mono<? extends T> value1, java.util.function.Function<? super T,reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting a generating function.
static <T1,T2,R1,R2,R> reactor.core.publisher.Mono<R>	forEach3(reactor.core.publisher.Mono<? extends T1> value1, java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting 2 generating functions.
static <T1,T2,T3,R1,R2,R3,R> reactor.core.publisher.Mono<R>	forEach4(reactor.core.publisher.Mono<? extends T1> value1, java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2, java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3, Fn3<? super T1,? super R1,? super R2,? extends reactor.core.publisher.Mono<R3>> value4, Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction) Perform a For Comprehension over a Mono, accepting 3 generating functions.
static <T> reactor.core.publisher.Mono<T>	fromIterable(java.lang.Iterable<T> t) Construct a Mono from Iterable by taking the first value from Iterable
static <T> Future<T>	future(reactor.core.publisher.Mono<T> future)
static <T> Future[]	futures(reactor.core.publisher.Mono<T>... futures)
static <T> java.util.Iterator<T>	iterator(reactor.core.publisher.Mono<T> pub) Get an Iterator for the value (if any) in the provided Mono
static <W extends WitnessType<W>,T> MonoT<W,T>	liftM(AnyM<W,reactor.core.publisher.Mono<T>> nested)
static <T,W extends WitnessType<W>> MonoT<W,T>	liftM(reactor.core.publisher.Mono<T> opt, W witness)
static <T,W2,R> Nested<ReactorWitness.mono,W2,R>	mapM(reactor.core.publisher.Mono<T> type, java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
static <T> Maybe<T>	maybe(reactor.core.publisher.Mono<T> opt)
static <R> reactor.core.publisher.Mono<R>	narrow(reactor.core.publisher.Mono<? extends R> apply)
static <T> reactor.core.publisher.Mono<ListX<T>>	quorum(java.util.function.Predicate<Status<T>> breakout, java.util.function.Consumer<java.lang.Throwable> errorHandler, reactor.core.publisher.Mono<T>... fts) Block until a Quorum of results have returned as determined by the provided Predicate
static <T> reactor.core.publisher.Mono<ListX<T>>	quorum(java.util.function.Predicate<Status<T>> breakout, reactor.core.publisher.Mono<T>... fts) Block until a Quorum of results have returned as determined by the provided Predicate
static <T> reactor.core.publisher.Mono<T>	raw(AnyM<ReactorWitness.mono,T> anyM)
static <T,R> reactor.core.publisher.Mono<R>	tailRec(T initial, java.util.function.Function<? super T,? extends reactor.core.publisher.Mono<? extends Xor<T,R>>> fn)
static <T> boolean	test(reactor.core.publisher.Mono<T> mono, T test) Test if value is equal to the value inside this Mono
static <W1 extends WitnessType<W1>,T> XorM<W1,ReactorWitness.mono,T>	xorM(reactor.core.publisher.Mono<T> type)
static <T1,T2,R> reactor.core.publisher.Mono<R>	zip(reactor.core.publisher.Mono<? extends T1> mono, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> app) Combine the provided Mono with the first element (if present) in the provided Publisher using the provided BiFunction
static <T1,T2,R> reactor.core.publisher.Mono<R>	zip(reactor.core.publisher.Mono<? extends T1> mono, java.lang.Iterable<? extends T2> app, java.util.function.BiFunction<? super T1,? super T2,? extends R> fn) Combine the provided Mono with the first element (if present) in the provided Iterable using the provided BiFunction

Methods inherited from class java.lang.Object

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

Constructor Detail

Monos

public Monos()

Method Detail

coproduct

public static <W1,T> Coproduct<W1,ReactorWitness.mono,T> coproduct(reactor.core.publisher.Mono<T> list,
                                                                   InstanceDefinitions<W1> def1)

coproduct

public static <W1,T> Coproduct<W1,ReactorWitness.mono,T> coproduct(T value,
                                                                   InstanceDefinitions<W1> def1)

xorM

public static <W1 extends WitnessType<W1>,T> XorM<W1,ReactorWitness.mono,T> xorM(reactor.core.publisher.Mono<T> type)

raw

public static <T> reactor.core.publisher.Mono<T> raw(AnyM<ReactorWitness.mono,T> anyM)

tailRec

public static <T,R> reactor.core.publisher.Mono<R> tailRec(T initial,
                                                           java.util.function.Function<? super T,? extends reactor.core.publisher.Mono<? extends Xor<T,R>>> fn)

liftM

public static <W extends WitnessType<W>,T> MonoT<W,T> liftM(AnyM<W,reactor.core.publisher.Mono<T>> nested)

liftM

public static <T,W extends WitnessType<W>> MonoT<W,T> liftM(reactor.core.publisher.Mono<T> opt,
                                                            W witness)

futures

public static <T> Future[] futures(reactor.core.publisher.Mono<T>... futures)

future

public static <T> Future<T> future(reactor.core.publisher.Mono<T> future)

either

public static <R> Either<java.lang.Throwable,R> either(reactor.core.publisher.Mono<R> either)

maybe

public static <T> Maybe<T> maybe(reactor.core.publisher.Mono<T> opt)

eval

public static <T> Eval<T> eval(reactor.core.publisher.Mono<T> opt)

anyM

public static <T> AnyMValue<ReactorWitness.mono,T> anyM(reactor.core.publisher.Mono<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 = Fluxs.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

anyOf

public static <T> reactor.core.publisher.Mono<T> anyOf(reactor.core.publisher.Mono<T>... fts)

Select the first Mono to complete

Parameters:

fts - Monos to race

Returns:

First Mono to complete

See Also:

CompletableFuture.anyOf(CompletableFuture...)

allOf

public static <T> reactor.core.publisher.Mono<T> allOf(reactor.core.publisher.Mono<T>... fts)

Wait until all the provided Future's to complete

Parameters:

fts - Monos to wait on

Returns:

Mono that completes when all the provided Futures Complete. Empty Future result, or holds an Exception from a provided Future that failed.

See Also:

CompletableFuture.allOf(CompletableFuture...)

quorum

@SafeVarargs
public static <T> reactor.core.publisher.Mono<ListX<T>> quorum(java.util.function.Predicate<Status<T>> breakout,
                                                                            java.util.function.Consumer<java.lang.Throwable> errorHandler,
                                                                            reactor.core.publisher.Mono<T>... fts)

Block until a Quorum of results have returned as determined by the provided Predicate

 

 Mono<ListX<Integer>> strings = Monos.quorum(status -> status.getCompleted() >0, Mono.deferred(()->1),Mono.empty(),Mono.empty());


    strings.get().size()
    //1

 
 

Parameters:

breakout - Predicate that determines whether the block should be continued or removed

fts - FutureWs to wait on results from

errorHandler - Consumer to handle any exceptions thrown

Returns:

Future which will be populated with a Quorum of results

quorum

@SafeVarargs
public static <T> reactor.core.publisher.Mono<ListX<T>> quorum(java.util.function.Predicate<Status<T>> breakout,
                                                                            reactor.core.publisher.Mono<T>... fts)

Block until a Quorum of results have returned as determined by the provided Predicate

 

 Mono<ListX<Integer>> strings = Monos.quorum(status -> status.getCompleted() >0, Mono.deferred(()->1),Mono.empty(),Mono.empty());


    strings.get().size()
    //1

 
 

Parameters:

breakout - Predicate that determines whether the block should be continued or removed

fts - Monos to wait on results from

Returns:

Mono which will be populated with a Quorum of results

firstSuccess

@SafeVarargs
public static <T> reactor.core.publisher.Mono<T> firstSuccess(reactor.core.publisher.Mono<T>... fts)

Select the first Future to return with a successful result

 
 Mono<Integer> ft = Mono.empty();
      Mono<Integer> result = Monos.firstSuccess(Mono.deferred(()->1),ft);

    ft.complete(10);
    result.get() //1
 
 

Parameters:

fts - Monos to race

Returns:

First Mono to return with a result

forEach4

public static <T1,T2,T3,R1,R2,R3,R> reactor.core.publisher.Mono<R> forEach4(reactor.core.publisher.Mono<? extends T1> value1,
                                                                            java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2,
                                                                            java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3,
                                                                            Fn3<? super T1,? super R1,? super R2,? extends reactor.core.publisher.Mono<R3>> value4,
                                                                            Fn4<? super T1,? super R1,? super R2,? super R3,? extends R> yieldingFunction)

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

 
    
   import static cyclops.companion.reactor.Monos.forEach4;
    
          forEach4(Mono.just(1), 
                  a-> Mono.just(a+1),
                  (a,b) -> Mono.<Integer>just(a+b),
                  (a,b,c) -> Mono.<Integer>just(a+b+c),
                  Tuple::tuple)
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

value3 - Nested Mono

value4 - Nested Mono

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach3

public static <T1,T2,R1,R2,R> reactor.core.publisher.Mono<R> forEach3(reactor.core.publisher.Mono<? extends T1> value1,
                                                                      java.util.function.Function<? super T1,? extends reactor.core.publisher.Mono<R1>> value2,
                                                                      java.util.function.BiFunction<? super T1,? super R1,? extends reactor.core.publisher.Mono<R2>> value3,
                                                                      Fn3<? super T1,? super R1,? super R2,? extends R> yieldingFunction)

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

 
    
   import static cyclops.companion.reactor.Monos.forEach3;
    
          forEach3(Mono.just(1), 
                  a-> Mono.just(a+1),
                  (a,b) -> Mono.<Integer>just(a+b),
                  Tuple::tuple)
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

value3 - Nested Mono

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

forEach

public static <T,R1,R> reactor.core.publisher.Mono<R> forEach(reactor.core.publisher.Mono<? extends T> value1,
                                                              java.util.function.Function<? super T,reactor.core.publisher.Mono<R1>> value2,
                                                              java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)

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

 
    
   import static cyclops.companion.reactor.Monos.forEach;
    
          forEach(Mono.just(1), 
                  a-> Mono.just(a+1),
                  Tuple::tuple)
 
 
 

Parameters:

value1 - top level Mono

value2 - Nested Mono

yieldingFunction - Generates a result per combination

Returns:

Mono with a combined value generated by the yielding function

combine

public static <T1,T2,R> reactor.core.publisher.Mono<R> combine(reactor.core.publisher.Mono<? extends T1> mono,
                                                               Value<? extends T2> app,
                                                               java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Lazily combine this Mono with the supplied value via the supplied BiFunction

Parameters:

mono - Mono to combine with another value

app - Value to combine with supplied mono

fn - Combiner function

Returns:

Combined Mono

combine

public static <T1,T2,R> reactor.core.publisher.Mono<R> combine(reactor.core.publisher.Mono<? extends T1> mono,
                                                               reactor.core.publisher.Mono<? extends T2> app,
                                                               java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Lazily combine this Mono with the supplied Mono via the supplied BiFunction

Parameters:

mono - Mono to combine with another value

app - Mono to combine with supplied mono

fn - Combiner function

Returns:

Combined Mono

zip

public static <T1,T2,R> reactor.core.publisher.Mono<R> zip(reactor.core.publisher.Mono<? extends T1> mono,
                                                           java.lang.Iterable<? extends T2> app,
                                                           java.util.function.BiFunction<? super T1,? super T2,? extends R> fn)

Combine the provided Mono with the first element (if present) in the provided Iterable using the provided BiFunction

Parameters:

mono - Mono to combine with an Iterable

app - Iterable to combine with a Mono

fn - Combining function

Returns:

Combined Mono

zip

public static <T1,T2,R> reactor.core.publisher.Mono<R> zip(reactor.core.publisher.Mono<? extends T1> mono,
                                                           java.util.function.BiFunction<? super T1,? super T2,? extends R> fn,
                                                           org.reactivestreams.Publisher<? extends T2> app)

Combine the provided Mono with the first element (if present) in the provided Publisher using the provided BiFunction

Parameters:

mono - Mono to combine with a Publisher

fn - Publisher to combine with a Mono

app - Combining function

Returns:

Combined Mono

test

public static <T> boolean test(reactor.core.publisher.Mono<T> mono,
                               T test)

Test if value is equal to the value inside this Mono

Parameters:

mono - Mono to test

test - Value to test

Returns:

true if equal

fromIterable

public static <T> reactor.core.publisher.Mono<T> fromIterable(java.lang.Iterable<T> t)

Construct a Mono from Iterable by taking the first value from Iterable

Parameters:

t - Iterable to populate Mono from

Returns:

Mono containing first element from Iterable (or empty Mono)

iterator

public static <T> java.util.Iterator<T> iterator(reactor.core.publisher.Mono<T> pub)

Get an Iterator for the value (if any) in the provided Mono

Parameters:

pub - Mono to get Iterator for

Returns:

Iterator over Mono value

narrow

public static <R> reactor.core.publisher.Mono<R> narrow(reactor.core.publisher.Mono<? extends R> apply)

allTypeclasses

public static <T> Active<ReactorWitness.mono,T> allTypeclasses(reactor.core.publisher.Mono<T> type)

mapM

public static <T,W2,R> Nested<ReactorWitness.mono,W2,R> mapM(reactor.core.publisher.Mono<T> type,
                                                             java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
                                                             InstanceDefinitions<W2> defs)