MonoT (cyclops-reactor 8.2.0 API)

Type Parameters:

A -

All Superinterfaces:

com.aol.cyclops.types.stream.ConvertableToReactiveSeq<A>, com.aol.cyclops.types.Filterable<A>, com.aol.cyclops.types.Functor<A>, java.lang.Iterable<A>, org.reactivestreams.Publisher<A>, com.aol.cyclops.types.stream.ToStream<A>, com.aol.cyclops.types.Unit<A>

All Known Implementing Classes:

MonoTSeq, MonoTValue
```
public interface MonoT<A>
extends com.aol.cyclops.types.Unit<A>, org.reactivestreams.Publisher<A>, com.aol.cyclops.types.Functor<A>, com.aol.cyclops.types.Filterable<A>, com.aol.cyclops.types.stream.ToStream<A>
```
Monad Transformer for Reactor Mono types. It allows users to manipulated Mono instances contained inside other monad types

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <B> MonoT<B>`	`bind(java.util.function.Function<? super A,MonoT<? extends B>> f)` FlatMap operation
`default <U> MonoT<U>`	`cast(java.lang.Class<? extends U> type)`
`<R> MonoT<R>`	`empty()`
`static <T> MonoTSeq<T>`	`emptyList()`
`static <T> MonoTValue<T>`	`emptyOptional()`
`MonoT<A>`	`filter(java.util.function.Predicate<? super A> test)`
`default MonoT<A>`	`filterNot(java.util.function.Predicate<? super A> fn)`
`<B> MonoT<B>`	`flatMap(java.util.function.Function<? super A,? extends com.aol.cyclops.types.MonadicValue<? extends B>> f)` flatMap operation
`static <A> MonoT<A>`	`fromAnyM(com.aol.cyclops.control.AnyM<A> anyM)` Construct an MonoT from an AnyM that contains a monad type that contains type other than Mono The values in the underlying monad will be mapped to Mono
`static <A> MonoTSeq<A>`	`fromAnyMSeq(com.aol.cyclops.types.anyM.AnyMSeq<A> anyM)` Create a MonoT from an AnyMSeq by wrapping the elements stored in the AnyMSeq in a Mono
`static <A> MonoTValue<A>`	`fromAnyMValue(com.aol.cyclops.types.anyM.AnyMValue<A> anyM)` Create a MonoT from an AnyMValue by wrapping the element stored in the AnyMValue in a Mono
`static <A> MonoTValue<A>`	`fromFuture(java.util.concurrent.CompletableFuture<reactor.core.publisher.Mono<A>> future)` Construct a MonoTValue from an CompletableFuture containing a Mono
`static <A> MonoTSeq<A>`	`fromIterable(java.lang.Iterable<reactor.core.publisher.Mono<A>> iterableOfMonos)` Create a MonoTSeq from an Iterable that contains nested Monos
`static <A> MonoTValue<A>`	`fromIterableValue(java.lang.Iterable<reactor.core.publisher.Mono<A>> iterableOfMonos)` Construct a MonoTValue from an Iterable containing a Mono
`static <A> MonoTValue<A>`	`fromMono(reactor.core.publisher.Mono<reactor.core.publisher.Mono<A>> mono)` Construct a MonoTValue from a Mono containing a Mono
`static <A> MonoTValue<A>`	`fromOptional(java.util.Optional<reactor.core.publisher.Mono<A>> optional)` Construct a MonoTValue from an Optional containing a Mono
`static <A> MonoTSeq<A>`	`fromPublisher(org.reactivestreams.Publisher<reactor.core.publisher.Mono<A>> publisherOfMonos)` Construct a MonoTSeq from a Publisher containing Monos
`static <A> MonoTSeq<A>`	`fromStream(java.util.stream.Stream<reactor.core.publisher.Mono<A>> streamOfMonos)` Construct a MonoTSeq from a Stream of Monos
`static <A,V extends com.aol.cyclops.types.MonadicValue<reactor.core.publisher.Mono<A>>> MonoTValue<A>`	`fromValue(V monadicValue)` Construct a MonoTValue from a cyclops-react MonadicValue (Maybe, Eval FutureW etc) containing a Mono
`static <U,R> java.util.function.Function<MonoT<U>,MonoT<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an CompletableFutureT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R> java.util.function.BiFunction<MonoT<U1>,MonoT<U2>,MonoT<R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns CompletableFutureTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`<B> MonoT<B>`	`map(java.util.function.Function<? super A,? extends B> f)` Map the wrapped Mono
`default MonoT<A>`	`notNull()`
`static <A> MonoT<A>`	`of(com.aol.cyclops.control.AnyM<reactor.core.publisher.Mono<A>> monads)` Construct an MonoT from an AnyM that wraps a monad containing Monos
`default <U> MonoT<U>`	`ofType(java.lang.Class<? extends U> type)`
`default <R> MonoT<R>`	`patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<A,R>,com.aol.cyclops.control.Matchable.CheckValue1<A,R>> case1, java.util.function.Supplier<? extends R> otherwise)`
`MonoT<A>`	`peek(java.util.function.Consumer<? super A> peek)` Peek at the current value of the Mono
`default <R> MonoT<R>`	`trampoline(java.util.function.Function<? super A,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)`
`com.aol.cyclops.control.AnyM<reactor.core.publisher.Mono<A>>`	`unwrap()`

Methods inherited from interface com.aol.cyclops.types.Unit
unit

Methods inherited from interface org.reactivestreams.Publisher
subscribe

Methods inherited from interface com.aol.cyclops.types.stream.ToStream
futureStream, getStreamable, isEmpty, iterator, jdkStream, reactiveSeq, reveresedJDKStream, reveresedStream, stream

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
 - filter
```
MonoT<A> filter(java.util.function.Predicate<? super A> test)
```
 Specified by:
 
 filter in interface com.aol.cyclops.types.Filterable<A>
 - empty
```
<R> MonoT<R> empty()
```
 Returns:
 
 An empty MonoT instance
 - bind
```
default  MonoT bind(java.util.function.Function<? super A,MonoT<? extends B>> f)
```
 FlatMap operation
 
 Parameters:
 
 f - Mapping function
 
 Returns:
 
 Mapped and flattened MonoT
 - of
```
static <A> MonoT<A> of(com.aol.cyclops.control.AnyM<reactor.core.publisher.Mono<A>> monads)
```
 Construct an MonoT from an AnyM that wraps a monad containing Monos
```
 
 MonoT<Integer> monoT = MonoT.of(AnyM.fromOptional(Optional.of(Mono.just(10)));
 
 
 
```
 Parameters:
 
 monads - AnyM that contains a monad wrapping an Mono
 
 Returns:
 
 MonoTransformer for manipulating nested Monos
 - unwrap
```
com.aol.cyclops.control.AnyM<reactor.core.publisher.Mono<A>> unwrap()
```
 Returns:
 
 The wrapped AnyM
 - peek
```
MonoT<A> peek(java.util.function.Consumer<? super A> peek)
```
 Peek at the current value of the Mono
```
 
 MonoT.of(AnyM.fromIterable(ListX.of(Mono.just(10)))
 .peek(System.out::println);
 
 //prints 10 
 
 
```
 Specified by:
 
 peek in interface com.aol.cyclops.types.Functor<A>
 
 Parameters:
 
 peek - Consumer to accept current value of CompletableFuture
 
 Returns:
 
 CompletableFutureT with peek call
 - map
```
 MonoT map(java.util.function.Function<? super A,? extends B> f)
```
 Map the wrapped Mono
```
 
 MonoT.of(AnyM.fromIterable(ListX.of(Mono.just(10)))
 .map(t->t+1);
 
 
 
 
```
 Specified by:
 
 map in interface com.aol.cyclops.types.Functor<A>
 
 Parameters:
 
 f - Mapping function for the wrapped Mono
 
 Returns:
 
 CompletableFutureT that applies the map function to the wrapped Mono
 - flatMap
```
 MonoT flatMap(java.util.function.Function<? super A,? extends com.aol.cyclops.types.MonadicValue<? extends B>> f)
```
 flatMap operation
```
 
 MonoT.of(AnyM.fromIterable(ListX.of(Mono.just(10)))
 .flatMap(t-> Maybe.just(t+1));
 
 
 
 
```
 Parameters:
 
 f - Mapping function
 
 Returns:
 
 flatMapped MonoT
 - lift
```
static <U,R> java.util.function.Function<MonoT,MonoT<R>> lift(java.util.function.Function<? super U,? extends R> fn)
```
 Lift a function into one that accepts and returns an CompletableFutureT This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling / iteration (via CompletableFuture) and iteration (via Stream) to an existing function
 
 Parameters:
 
 fn - Function to enhance with functionality from CompletableFuture and another monad type
 
 Returns:
 
 Function that accepts and returns an CompletableFutureT
 - lift2
```
static <U1,U2,R> java.util.function.BiFunction<MonoT<U1>,MonoT<U2>,MonoT<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
```
 Lift a BiFunction into one that accepts and returns CompletableFutureTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling / iteration (via CompletableFuture), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function
 
 Parameters:
 
 fn - BiFunction to enhance with functionality from CompletableFuture and another monad type
 
 Returns:
 
 Function that accepts and returns an CompletableFutureT
 - fromAnyM
```
static <A> MonoT<A> fromAnyM(com.aol.cyclops.control.AnyM<A> anyM)
```
 Construct an MonoT from an AnyM that contains a monad type that contains type other than Mono The values in the underlying monad will be mapped to Mono
 
 Parameters:
 
 anyM - AnyM that doesn't contain a monad wrapping an Mono
 
 Returns:
 
 MonoTransformer for manipulating nested Monos
 - fromAnyMValue
```
static <A> MonoTValue<A> fromAnyMValue(com.aol.cyclops.types.anyM.AnyMValue<A> anyM)
```
 Create a MonoT from an AnyMValue by wrapping the element stored in the AnyMValue in a Mono
 
 Parameters:
 
 anyM - Monad to embed a Mono inside (wrapping it's current value)
 
 Returns:
 
 MonoTransformer for manipulating nested Monos
 - fromAnyMSeq
```
static <A> MonoTSeq<A> fromAnyMSeq(com.aol.cyclops.types.anyM.AnyMSeq<A> anyM)
```
 Create a MonoT from an AnyMSeq by wrapping the elements stored in the AnyMSeq in a Mono
 
 Parameters:
 
 anyM - Monad to embed a Mono inside (wrapping it's current values individually in Monos)
 
 Returns:
 
 MonoTransformer for manipulating nested Monos
 - fromIterable
```
static <A> MonoTSeq<A> fromIterable(java.lang.Iterable<reactor.core.publisher.Mono<A>> iterableOfMonos)
```
 Create a MonoTSeq from an Iterable that contains nested Monos
```
 
 MonoTSeq<Integer> monoT = MonoT.fromIterable(Arrays.asList(Mono.just(1));
 
 
```
 Parameters:
 
 iterableOfMonos - An Iterable containing nested Monos
 
 Returns:
 
 MonoTransformer for manipulating nested Monos
 - fromStream
```
static <A> MonoTSeq<A> fromStream(java.util.stream.Stream<reactor.core.publisher.Mono<A>> streamOfMonos)
```
 Construct a MonoTSeq from a Stream of Monos
```
 
 MonoTSeq<Integer> monoT = MonoT.fromStream(Stream.of(Mono.just(1));
 
 
```
 Parameters:
 
 streamOfMonos - Stream containing nested Monos
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - fromPublisher
```
static <A> MonoTSeq<A> fromPublisher(org.reactivestreams.Publisher<reactor.core.publisher.Mono<A>> publisherOfMonos)
```
 Construct a MonoTSeq from a Publisher containing Monos
```
 
 MonoTSeq<Integer> monoT = MonoT.fromPublisher(Flux.just(Mono.just(1));
 
 
```
 Parameters:
 
 publisherOfMonos - Publisher containing nested Monos
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - fromValue
```
static <A,V extends com.aol.cyclops.types.MonadicValue<reactor.core.publisher.Mono<A>>> MonoTValue<A> fromValue(V monadicValue)
```
 Construct a MonoTValue from a cyclops-react MonadicValue (Maybe, Eval FutureW etc) containing a Mono
```
 
 MonoTValue<Integer> monoT = MonoT.fromValue(Maybe.just(Mono.just(1));
 
 
```
 Parameters:
 
 monadicValue - MonadicValue containing a nested Mono
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - fromOptional
```
static <A> MonoTValue<A> fromOptional(java.util.Optional<reactor.core.publisher.Mono<A>> optional)
```
 Construct a MonoTValue from an Optional containing a Mono
```
 
 MonoTValue<Integer> monoT = MonoT.fromOptional(Optional.of(Mono.just(1));
 
 
```
 Parameters:
 
 optional - Optional containing a nested Mono
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - fromFuture
```
static <A> MonoTValue<A> fromFuture(java.util.concurrent.CompletableFuture<reactor.core.publisher.Mono<A>> future)
```
 Construct a MonoTValue from an CompletableFuture containing a Mono
```
 
 MonoTValue<Integer> monoT = MonoT.fromFuture(CompletableFuture.completedFuture(Mono.just(1));
 
 
```
 Parameters:
 
 future - Future containing a nested Mono
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - fromMono
```
static <A> MonoTValue<A> fromMono(reactor.core.publisher.Mono<reactor.core.publisher.Mono<A>> mono)
```
 Construct a MonoTValue from a Mono containing a Mono
```
 
 MonoTValue<Integer> monoT = MonoT.fromFuture(Mono.just(Mono.just(1));
 
 
```
 Parameters:
 
 future - Mono containing a nested Mono
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - fromIterableValue
```
static <A> MonoTValue<A> fromIterableValue(java.lang.Iterable<reactor.core.publisher.Mono<A>> iterableOfMonos)
```
 Construct a MonoTValue from an Iterable containing a Mono
```
 
 MonoTValue<Integer> monoT = MonoT.fromIterableValue(Arrays.asList(Mono.just(1));
 
 
```
 Parameters:
 
 iterableOfMonos - An Iterable containing a Mono
 
 Returns:
 
 Mono Transformer for manipulating nested Monos
 - emptyOptional
```
static <T> MonoTValue<T> emptyOptional()
```
 Returns:
 
 An empty MonoTValue (wraps an Empty Optional)
 - emptyList
```
static <T> MonoTSeq<T> emptyList()
```
 Returns:
 
 An empty MonoTSeq (wraps an Empty List)
 - cast
```
default  MonoT cast(java.lang.Class<? extends U> type)
```
 Specified by:
 
 cast in interface com.aol.cyclops.types.Functor<A>
 - trampoline
```
default <R> MonoT<R> trampoline(java.util.function.Function<? super A,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)
```
 Specified by:
 
 trampoline in interface com.aol.cyclops.types.Functor<A>
 - patternMatch
```
default <R> MonoT<R> patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<A,R>,com.aol.cyclops.control.Matchable.CheckValue1<A,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Specified by:
 
 patternMatch in interface com.aol.cyclops.types.Functor<A>
 - ofType
```
default  MonoT ofType(java.lang.Class<? extends U> type)
```
 Specified by:
 
 ofType in interface com.aol.cyclops.types.Filterable<A>
 - filterNot
```
default MonoT<A> filterNot(java.util.function.Predicate<? super A> fn)
```
 Specified by:
 
 filterNot in interface com.aol.cyclops.types.Filterable<A>
 - notNull
```
default MonoT<A> notNull()
```
 Specified by:
 
 notNull in interface com.aol.cyclops.types.Filterable<A>

Interface MonoT<A>

Method Summary

Methods inherited from interface com.aol.cyclops.types.Unit

Methods inherited from interface org.reactivestreams.Publisher

Methods inherited from interface com.aol.cyclops.types.stream.ToStream

Methods inherited from interface java.lang.Iterable

Method Detail

filter

empty

bind

of

unwrap

peek

map

flatMap

lift

lift2

fromAnyM

fromAnyMValue

fromAnyMSeq

fromIterable

fromStream

fromPublisher

fromValue

fromOptional

fromFuture

fromMono

fromIterableValue

emptyOptional

emptyList

cast

trampoline

patternMatch

ofType

filterNot

notNull