MonoT (cyclops-reactor 8.4.2 API)

Type Parameters:

A -

All Superinterfaces:

ConvertableToReactiveSeq<A>, Filterable<A>, Functor<A>, java.lang.Iterable<A>, org.reactivestreams.Publisher<A>, ToStream<A>, Unit<A>

All Known Implementing Classes:

MonoTSeq, MonoTValue
```
public interface MonoT<A>
extends Unit<A>, org.reactivestreams.Publisher<A>, Functor<A>, Filterable<A>, 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)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`<R> MonoT<R>`	`empty()`
`static <T> MonoTSeq<T>`	`emptyList()`
`static <T> MonoTValue<T>`	`emptyOptional()`
`MonoT<A>`	`filter(java.util.function.Predicate<? super A> test)` Keep only elements for which the supplied predicates hold e.g.
`default MonoT<A>`	`filterNot(java.util.function.Predicate<? super A> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> MonoT<B>`	`flatMap(java.util.function.Function<? super A,? extends MonadicValue<? extends B>> f)` flatMap operation
`static <A> MonoT<A>`	`fromAnyM(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(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(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 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()` Filter elements retaining only values which are not null
`static <A> MonoT<A>`	`of(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)` Keep only those elements in a stream that are of a given type.
`default <R> MonoT<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<A,R>,Matchable.CheckValue1<A,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`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 Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`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)
```
 Description copied from interface: Filterable
 Keep only elements for which the supplied predicates hold e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[3]
 
 
 
```
 Specified by:
 
 filter in interface Filterable<A>
 
 Parameters:
 
 test - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - 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(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
```
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 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 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 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(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(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(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 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)
```
 Description copied from interface: Functor
 
 Cast all elements in a stream to a given type, possibly throwing a ClassCastException. // ClassCastException ReactiveSeq.of(1, "a", 2, "b", 3).cast(Integer.class)
 
 Specified by:
 
 cast in interface Functor<A>
 - trampoline
```
default <R> MonoT<R> trampoline(java.util.function.Function<? super A,? extends Trampoline<? extends R>> mapper)
```
 Description copied from interface: Functor
 Performs a map operation that can call a recursive method without running out of stack space
```
 
 ReactiveSeq.of(10,20,30,40)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println); 
 			 
 	Trampoline<Long> fibonacci(int i){
 		return fibonacci(i,1,0);
 	}
 	Trampoline<Long> fibonacci(int n, long a, long b) {
 	return n == 0 ? Trampoline.done(b) : Trampoline.more( ()->fibonacci(n-1, a+b, a));
 	}		 
 			 
 55
 	6765
 	832040
 	102334155
 
 
 ReactiveSeq.of(10_000,200_000,3_000_000,40_000_000)
 			 .trampoline(i-> fibonacci(i))
 			 .forEach(System.out::println);
 			 
 			 
 completes successfully
 
 
```
 Specified by:
 
 trampoline in interface Functor<A>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - patternMatch
```
default <R> MonoT<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<A,R>,Matchable.CheckValue1<A,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Description copied from interface: Functor
 Transform the elements of this Stream with a Pattern Matching case and default value
```
 
 List<String> result = CollectionX.of(1,2,3,4)
 .patternMatch(
 c->c.valuesWhere(i->"even", (Integer i)->i%2==0 )
 )
 
 // CollectionX["odd","even","odd","even"]
 
```
 Specified by:
 
 patternMatch in interface Functor<A>
 
 Parameters:
 
 case1 - Function to generate a case (or chain of cases as a single case)
 
 otherwise - Value if supplied case doesn't match
 
 Returns:
 
 CollectionX where elements are transformed by pattern matching
 - ofType
```
default  MonoT ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filterable
 Keep only those elements in a stream that are of a given type.
```
 
 
 // (1, 2, 3) ReactiveSeq.of(1, "a", 2, "b",3).ofType(Integer.class)
 
 
 
```
 Specified by:
 
 ofType in interface Filterable<A>
 - filterNot
```
default MonoT<A> filterNot(java.util.function.Predicate<? super A> fn)
```
 Description copied from interface: Filterable
 Remove any elements for which the predicate holds (inverse operation to filter) e.g.
```
 
 
 of(1,2,3).filter(i->i>2);
 
 //[1,2]
 
 
 
```
 Specified by:
 
 filterNot in interface Filterable<A>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
default MonoT<A> notNull()
```
 Description copied from interface: Filterable
 Filter elements retaining only values which are not null
```
 
 
 of(1,2,null,4).nonNull();
 
 //[1,2,4]
 
 
 
```
 Specified by:
 
 notNull in interface Filterable<A>
 
 Returns:
 
 Filterable with nulls removed

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