FluxT (cyclops-reactor 8.2.0 API)

Type Parameters:

T - the type of elements held in the nested Fluxes

All Superinterfaces:

com.aol.cyclops.types.stream.ConvertableSequence<T>, com.aol.cyclops.types.stream.ConvertableToReactiveSeq<T>, com.aol.cyclops.types.Filterable<T>, com.aol.cyclops.types.FilterableFunctor<T>, com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq<T>, com.aol.cyclops.types.Functor<T>, java.lang.Iterable<T>, com.aol.cyclops.types.anyM.NestedCollectable<T>, com.aol.cyclops.types.anyM.NestedFoldable<T>, com.aol.cyclops.types.OnEmpty<T>, org.reactivestreams.Publisher<T>, com.aol.cyclops.types.Sequential<T>, com.aol.cyclops.types.stream.ToStream<T>, com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>, com.aol.cyclops.types.Traversable<T>, com.aol.cyclops.types.Zippable<T>

All Known Implementing Classes:

FluxTSeq, FluxTValue
```
public interface FluxT<T>
extends com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq<T>
```
Monad Transformer for Reactor Flux types. It allows users to manipulated Flux 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> FluxT<B>`	`bind(java.util.function.Function<? super T,FluxT<? extends B>> f)` Flat Map the wrapped Flux
`default <U> FluxT<U>`	`cast(java.lang.Class<? extends U> type)`
`default FluxT<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)`
`default FluxT<T>`	`cycle(int times)`
`default FluxT<T>`	`cycle(com.aol.cyclops.Monoid<T> m, int times)`
`default FluxT<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)`
`default FluxT<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)`
`default FluxT<T>`	`distinct()`
`default FluxT<T>`	`dropRight(int num)`
`default FluxT<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default FluxT<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`<R> FluxT<R>`	`empty()`
`static <T> FluxTSeq<T>`	`emptyFlux()`
`static <T> FluxTValue<T>`	`emptyOptional()`
`FluxT<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Flux
`default FluxT<T>`	`filterNot(java.util.function.Predicate<? super T> fn)`
`<B> FluxT<B>`	`flatMap(java.util.function.Function<? super T,? extends reactor.core.publisher.Flux<? extends B>> f)` Perform a flatMap operation on each nested Flux
`reactor.core.publisher.Flux<T>`	`flux()`
`default reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>`	`fluxOfFlux()` Convert this FluxTransformer into a Flux of Fluxes
`static <A> FluxT<A>`	`fromAnyM(com.aol.cyclops.control.AnyM<A> anyM)` Construct an FluxT from an AnyM that contains a monad type that contains type other than Flux The values in the underlying monad will be mapped to Flux
`static <A> FluxTSeq<A>`	`fromAnyMSeq(com.aol.cyclops.types.anyM.AnyMSeq<A> anyM)` Create a FluxT from an AnyMSeq by wrapping the elements stored in the AnyMSeq in a Flux
`static <A> FluxTValue<A>`	`fromAnyMValue(com.aol.cyclops.types.anyM.AnyMValue<A> anyM)` Create a FluxT from an AnyMValue by wrapping the element stored in the AnyMValue in a Flux
`static <A> FluxTValue<A>`	`fromFuture(java.util.concurrent.CompletableFuture<reactor.core.publisher.Flux<A>> future)` Create a FluxTValue from a JDK CompletableFuture that contains nested Fluxes
`static <A> FluxTSeq<A>`	`fromIterable(java.lang.Iterable<reactor.core.publisher.Flux<A>> iterableOfFluxs)` Create a FluxT from an Iterable that contains nested Fluxes
`static <A> FluxTValue<A>`	`fromIterableValue(java.lang.Iterable<reactor.core.publisher.Flux<A>> iterableOfFluxs)` Create a FluxTValue from an Iterable that contains nested Fluxes
`static <A> FluxTValue<A>`	`fromMono(reactor.core.publisher.Mono<reactor.core.publisher.Flux<A>> mono)` Create a FluxTValue from a Reactor Mono type that contains nested Fluxes
`static <A> FluxTValue<A>`	`fromOptional(java.util.Optional<reactor.core.publisher.Flux<A>> optional)` Create a FluxTValue from a JDK Optional that contains nested Fluxes
`static <A> FluxTSeq<A>`	`fromPublisher(org.reactivestreams.Publisher<reactor.core.publisher.Flux<A>> publisherOfFluxs)` Create a FluxTSeq from a Publisher that contains nested Fluxes
`static <A,V extends com.aol.cyclops.types.MonadicValue<? extends reactor.core.publisher.Flux<A>>> FluxTValue<A>`	`fromValue(V monadicValue)` Create a FluxTValue from a cyclops-react Value that contains nested Fluxes
`default <K> FluxT<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`default <K,A,D> FluxT<org.jooq.lambda.tuple.Tuple2<K,D>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier, java.util.stream.Collector<? super T,A,D> downFlux)`
`default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`grouped(int groupSize)`
`default <C extends java.util.Collection<? super T>> FluxT<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)`
`default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<com.aol.cyclops.data.collections.extensions.standard.ListX<? super T>,? super T> predicate)`
`default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)`
`default <C extends java.util.Collection<? super T>> FluxT<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)`
`default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)`
`default <C extends java.util.Collection<? super T>> FluxT<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)`
`default FluxT<T>`	`intersperse(T value)`
`static <U,R> java.util.function.Function<FluxT<U>,FluxT<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an FluxT This allows multiple monad types to add functionality to existing functions and methods e.g.
`default FluxT<T>`	`limit(long num)`
`default FluxT<T>`	`limitLast(int num)`
`default FluxT<T>`	`limitUntil(java.util.function.Predicate<? super T> p)`
`default FluxT<T>`	`limitWhile(java.util.function.Predicate<? super T> p)`
`<B> FluxT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Flux
`default FluxT<T>`	`notNull()`
`static <A> FluxT<A>`	`of(com.aol.cyclops.control.AnyM<? extends reactor.core.publisher.Flux<A>> monads)` Create a FluxT from an AnyM that wraps a monad containing a Flux
`default <U> FluxT<U>`	`ofType(java.lang.Class<? extends U> type)`
`default FluxT<T>`	`onEmpty(T value)`
`default FluxT<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`default <X extends java.lang.Throwable> FluxT<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`default <R> FluxT<R>`	`patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<T,R>,com.aol.cyclops.control.Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)`
`FluxT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Flux
`default FluxT<T>`	`reverse()`
`default FluxT<T>`	`scanLeft(com.aol.cyclops.Monoid<T> monoid)`
`default <U> FluxT<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)`
`default FluxT<T>`	`scanRight(com.aol.cyclops.Monoid<T> monoid)`
`default <U> FluxT<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)`
`default FluxT<T>`	`shuffle()`
`default FluxT<T>`	`shuffle(java.util.Random random)`
`default FluxT<T>`	`skip(long num)`
`default FluxT<T>`	`skipLast(int num)`
`default FluxT<T>`	`skipUntil(java.util.function.Predicate<? super T> p)`
`default FluxT<T>`	`skipWhile(java.util.function.Predicate<? super T> p)`
`default FluxT<T>`	`slice(long from, long to)`
`default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`sliding(int windowSize)`
`default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>>`	`sliding(int windowSize, int increment)`
`default FluxT<T>`	`sorted()`
`default FluxT<T>`	`sorted(java.util.Comparator<? super T> c)`
`default <U extends java.lang.Comparable<? super U>> FluxT<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default FluxT<T>`	`takeRight(int num)`
`default FluxT<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default FluxT<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default <R> FluxT<R>`	`trampoline(java.util.function.Function<? super T,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)`
`<R> FluxT<R>`	`unit(R t)` Create an instance of the same FluxTransformer that contains a Flux with just the value provided
`<R> FluxT<R>`	`unitIterator(java.util.Iterator<R> it)` Create an instance of the same FluxTransformer type from the provided Iterator over raw values.
`com.aol.cyclops.control.AnyM<reactor.core.publisher.Flux<T>>`	`unwrap()`
`default <U> FluxT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <U,R> FluxT<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> FluxT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)`
`default <U,R> FluxT<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> FluxT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)`
`default <U,R> FluxT<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <S,U> FluxT<org.jooq.lambda.tuple.Tuple3<T,S,U>>`	`zip3(java.util.stream.Stream<? extends S> second, java.util.stream.Stream<? extends U> third)`
`default <T2,T3,T4> FluxT<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<? extends T2> second, java.util.stream.Stream<? extends T3> third, java.util.stream.Stream<? extends T4> fourth)`
`default FluxT<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()`

Methods inherited from interface com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq
stream

Methods inherited from interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq
futureOperations, isSeqPresent, lazyOperations, subscribe, transformerStream, unitAnyM

Methods inherited from interface com.aol.cyclops.types.stream.ConvertableSequence
seq, toCompletableFuture, toDequeX, toEvalAlways, toEvalLater, toEvalNow, toFutureStream, toFutureStream, toFutureW, toIor, toIorSecondary, toListX, toMapX, toMaybe, toOptional, toPBagX, toPMapX, toPOrderedSetX, toPQueueX, toPSetX, toPStackX, toPVectorX, toQueueX, toSetX, toSimpleReact, toSimpleReact, toSortedSetX, toStreamable, toTry, toValue, toValueMap, toValueSet, toXor, toXorSecondary

Methods inherited from interface com.aol.cyclops.types.Traversable
traversable

Methods inherited from interface com.aol.cyclops.types.Zippable
zip

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

Methods inherited from interface com.aol.cyclops.types.Sequential
fixedDelay, onePer, xPer

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

Methods inherited from interface com.aol.cyclops.types.anyM.NestedFoldable
endsWith, endsWithIterable, findFirst, firstValue, foldRight, foldRight, foldRight, foldRightMapToType, get, groupBy, headAndTail, join, join, join, mapReduce, mapReduce, nestedFoldables, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit

Methods inherited from interface com.aol.cyclops.types.anyM.NestedCollectable
allMatch, anyMatch, collect, collect, listT, nestedCollectables, noneMatch, setT, streamableT, streamT, toListOfLists, toNestedListX, toNestedSetX, toSetOfSets

- Method Detail
 - unitIterator
```
<R> FluxT<R> unitIterator(java.util.Iterator<R> it)
```
 Create an instance of the same FluxTransformer type from the provided Iterator over raw values.
```
 
 FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.just(1,2,3),Flux.just(4,5,6));
 FluxT<String> fluxTStrings = fluxT.unitIterator(Arrays.asList("hello","world").iterator());
 //List[Flux["hello","world"]]
 
 
 
```
 Parameters:
 
 it - Iterator over raw values to add to a new Flux Transformer
 
 Returns:
 
 Flux Transformer of the same type over the raw value in the Iterator provided
 - unit
```
<R> FluxT<R> unit(R t)
```
 Create an instance of the same FluxTransformer that contains a Flux with just the value provided
```
 
 FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.just(1,2,3),Flux.just(4,5,6));
 FluxT<String> fluxTStrings = fluxT.unit("hello");
 //List[Flux["hello"]]
 
 
 
```
 Parameters:
 
 t - Value to embed in new Flux Transformer
 
 Returns:
 
 Flux Transformer of the same type over the raw value provided
 - empty
```
<R> FluxT<R> empty()
```
 Returns:
 
 An empty Flux Transformer of the same type
 - flatMap
```
 FluxT flatMap(java.util.function.Function<? super T,? extends reactor.core.publisher.Flux<? extends B>> f)
```
 Perform a flatMap operation on each nested Flux
 
 Parameters:
 
 f - FlatMapping function
 
 Returns:
 
 FluxTransformer containing flatMapped Fluxes
 - fluxOfFlux
```
default reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> fluxOfFlux()
```
 Convert this FluxTransformer into a Flux of Fluxes
```
 
 FluxT<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.just(1,2,3),Flux.just(4,5,6));
 Flux<Flux<Integer>> fluxes = fluxT.fluxOfFlux();
 //Flux[Flux[1,2,3],Flux[4,5,6]]
 
 
 
```
 Returns:
 
 Flux of Fluxes
 - unwrap
```
com.aol.cyclops.control.AnyM<reactor.core.publisher.Flux<T>> unwrap()
```
 Returns:
 
 The wrapped AnyM
 - peek
```
FluxT<T> peek(java.util.function.Consumer<? super T> peek)
```
 Peek at the current value of the Flux
```
 
 FluxT.of(AnyM.fromFlux(Arrays.asFlux(10))
 .peek(System.out::println);
 
 //prints 10 
 
 
```
 Specified by:
 
 peek in interface com.aol.cyclops.types.Functor<T>
 
 Parameters:
 
 peek - Consumer to accept current value of Flux
 
 Returns:
 
 FluxT with peek call
 - filter
```
FluxT<T> filter(java.util.function.Predicate<? super T> test)
```
 Filter the wrapped Flux
```
 
 FluxT.of(AnyM.fromFlux(Arrays.asFlux(10,11))
 .filter(t->t!=10);
 
 //FluxT<AnyM<Flux<Flux[11]>>>
 
 
```
 Specified by:
 
 filter in interface com.aol.cyclops.types.Filterable<T>
 
 Specified by:
 
 filter in interface com.aol.cyclops.types.FilterableFunctor<T>
 
 Parameters:
 
 test - Predicate to filter the wrapped Flux
 
 Returns:
 
 FluxT that applies the provided filter
 - map
```
 FluxT map(java.util.function.Function<? super T,? extends B> f)
```
 Map the wrapped Flux
```
 
 FluxT.of(AnyM.fromFlux(Arrays.asFlux(10))
 .map(t->t=t+1);
 
 
 //FluxT<AnyM<Flux<Flux[11]>>>
 
 
```
 Specified by:
 
 map in interface com.aol.cyclops.types.FilterableFunctor<T>
 
 Specified by:
 
 map in interface com.aol.cyclops.types.Functor<T>
 
 Parameters:
 
 f - Mapping function for the wrapped Flux
 
 Returns:
 
 FluxT that applies the map function to the wrapped Flux
 - bind
```
default  FluxT bind(java.util.function.Function<? super T,FluxT<? extends B>> f)
```
 Flat Map the wrapped Flux
```
 
 FluxT.of(AnyM.fromFlux(Flux.just(10))
 .flatMap(t->Flux.empty());
 
 
 //FluxT<AnyM<Flux<Flux.empty>>>
 
 
```
 Parameters:
 
 f - FlatMap function
 
 Returns:
 
 FluxT that applies the flatMap function to the wrapped Flux
 - lift
```
static <U,R> java.util.function.Function<FluxT,FluxT<R>> lift(java.util.function.Function<? super U,? extends R> fn)
```
 Lift a function into one that accepts and returns an FluxT This allows multiple monad types to add functionality to existing functions and methods e.g. to add iteration handling (via Flux) and nullhandling (via Optional) to an existing function
 
 Parameters:
 
 fn - Function to enhance with functionality from Flux and another monad type
 
 Returns:
 
 Function that accepts and returns an FluxT
 - fromAnyM
```
static <A> FluxT<A> fromAnyM(com.aol.cyclops.control.AnyM<A> anyM)
```
 Construct an FluxT from an AnyM that contains a monad type that contains type other than Flux The values in the underlying monad will be mapped to Flux
 
 Parameters:
 
 anyM - AnyM that doesn't contain a monad wrapping an Flux
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - of
```
static <A> FluxT<A> of(com.aol.cyclops.control.AnyM<? extends reactor.core.publisher.Flux<A>> monads)
```
 Create a FluxT from an AnyM that wraps a monad containing a Flux
```
 
 FluxT<Integer> fluxT = FluxT.of(AnyM.fromOptional(Optional.of(Flux.just(1,2,3)));
 
 
```
 Parameters:
 
 monads - AnyM containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromAnyMValue
```
static <A> FluxTValue<A> fromAnyMValue(com.aol.cyclops.types.anyM.AnyMValue<A> anyM)
```
 Create a FluxT from an AnyMValue by wrapping the element stored in the AnyMValue in a Flux
 
 Parameters:
 
 anyM - Monad to embed a Flux inside (wrapping it's current value)
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromAnyMSeq
```
static <A> FluxTSeq<A> fromAnyMSeq(com.aol.cyclops.types.anyM.AnyMSeq<A> anyM)
```
 Create a FluxT from an AnyMSeq by wrapping the elements stored in the AnyMSeq in a Flux
 
 Parameters:
 
 anyM - Monad to embed a Flux inside (wrapping it's current values individually in Fluxes)
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromIterable
```
static <A> FluxTSeq<A> fromIterable(java.lang.Iterable<reactor.core.publisher.Flux<A>> iterableOfFluxs)
```
 Create a FluxT from an Iterable that contains nested Fluxes
```
 
 FluxTSeq<Integer> fluxT = FluxT.fromIterable(Arrays.asList(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 iterableOfFluxs - An Iterable containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromPublisher
```
static <A> FluxTSeq<A> fromPublisher(org.reactivestreams.Publisher<reactor.core.publisher.Flux<A>> publisherOfFluxs)
```
 Create a FluxTSeq from a Publisher that contains nested Fluxes
```
 
 FluxTSeq<Integer> fluxT = FluxT.fromPublisher(Flux.just(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 publisherOfFluxs - A Publisher containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromValue
```
static <A,V extends com.aol.cyclops.types.MonadicValue<? extends reactor.core.publisher.Flux<A>>> FluxTValue<A> fromValue(V monadicValue)
```
 Create a FluxTValue from a cyclops-react Value that contains nested Fluxes
```
 
 FluxTValue<Integer> fluxT = FluxT.fromValue(Maybe.just(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 monadicValue - A Value containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromOptional
```
static <A> FluxTValue<A> fromOptional(java.util.Optional<reactor.core.publisher.Flux<A>> optional)
```
 Create a FluxTValue from a JDK Optional that contains nested Fluxes
```
 
 FluxTValue<Integer> fluxT = FluxT.fromOptional(Optional.of(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 optional - An Optional containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromFuture
```
static <A> FluxTValue<A> fromFuture(java.util.concurrent.CompletableFuture<reactor.core.publisher.Flux<A>> future)
```
 Create a FluxTValue from a JDK CompletableFuture that contains nested Fluxes
```
 
 FluxTValue<Integer> fluxT = FluxT.fromFuture(CompletableFuture.completedFuture(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 future - A CompletableFuture containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromMono
```
static <A> FluxTValue<A> fromMono(reactor.core.publisher.Mono<reactor.core.publisher.Flux<A>> mono)
```
 Create a FluxTValue from a Reactor Mono type that contains nested Fluxes
```
 
 FluxTValue<Integer> fluxT = FluxT.fromMono(Mono.just(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 future - A Mono containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - fromIterableValue
```
static <A> FluxTValue<A> fromIterableValue(java.lang.Iterable<reactor.core.publisher.Flux<A>> iterableOfFluxs)
```
 Create a FluxTValue from an Iterable that contains nested Fluxes
```
 
 FluxTValue<Integer> fluxT = FluxT.fromIterableValue(Arrays.asList(Flux.just(1,2,3));
 
 
```
 Parameters:
 
 iterableOfFluxs - An Iterable containing nested Fluxes
 
 Returns:
 
 FluxTransformer for manipulating nested Fluxes
 - emptyOptional
```
static <T> FluxTValue<T> emptyOptional()
```
 Returns:
 
 An empty FluxValue (wraps an Empty Optional)
 - emptyFlux
```
static <T> FluxTSeq<T> emptyFlux()
```
 Returns:
 
 An empty FluxTransformer (contains an empty Flux)
 - flux
```
reactor.core.publisher.Flux<T> flux()
```
 Returns:
 
 Flatten the data in this FluxTransformer into a single Flux
 - cast
```
default  FluxT cast(java.lang.Class<? extends U> type)
```
 Specified by:
 
 cast in interface com.aol.cyclops.types.Functor<T>
 - trampoline
```
default <R> FluxT<R> trampoline(java.util.function.Function<? super T,? extends com.aol.cyclops.control.Trampoline<? extends R>> mapper)
```
 Specified by:
 
 trampoline in interface com.aol.cyclops.types.Functor<T>
 - patternMatch
```
default <R> FluxT<R> patternMatch(java.util.function.Function<com.aol.cyclops.control.Matchable.CheckValue1<T,R>,com.aol.cyclops.control.Matchable.CheckValue1<T,R>> case1,
 java.util.function.Supplier<? extends R> otherwise)
```
 Specified by:
 
 patternMatch in interface com.aol.cyclops.types.Functor<T>
 - ofType
```
default  FluxT ofType(java.lang.Class<? extends U> type)
```
 Specified by:
 
 ofType in interface com.aol.cyclops.types.Filterable<T>
 - filterNot
```
default FluxT<T> filterNot(java.util.function.Predicate<? super T> fn)
```
 Specified by:
 
 filterNot in interface com.aol.cyclops.types.Filterable<T>
 - notNull
```
default FluxT<T> notNull()
```
 Specified by:
 
 notNull in interface com.aol.cyclops.types.Filterable<T>
 - combine
```
default FluxT<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Specified by:
 
 combine in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 combine in interface com.aol.cyclops.types.Traversable<T>
 - cycle
```
default FluxT<T> cycle(int times)
```
 Specified by:
 
 cycle in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.types.Traversable<T>
 - cycle
```
default FluxT<T> cycle(com.aol.cyclops.Monoid<T> m,
 int times)
```
 Specified by:
 
 cycle in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 cycle in interface com.aol.cyclops.types.Traversable<T>
 - cycleWhile
```
default FluxT<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 cycleWhile in interface com.aol.cyclops.types.Traversable<T>
 - cycleUntil
```
default FluxT<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 cycleUntil in interface com.aol.cyclops.types.Traversable<T>
 - zip
```
default <U,R> FluxT<R> zip(java.lang.Iterable<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 - zip
```
default <U,R> FluxT<R> zip(org.jooq.lambda.Seq<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 - zip
```
default <U,R> FluxT<R> zip(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 - zip
```
default  FluxT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
```
 Specified by:
 
 zip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 - zip
```
default  FluxT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Specified by:
 
 zip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 - zip
```
default  FluxT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Specified by:
 
 zip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Traversable<T>
 
 Specified by:
 
 zip in interface com.aol.cyclops.types.Zippable<T>
 - zip3
```
default <S,U> FluxT<org.jooq.lambda.tuple.Tuple3<T,S,U>> zip3(java.util.stream.Stream<? extends S> second,
 java.util.stream.Stream<? extends U> third)
```
 Specified by:
 
 zip3 in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip3 in interface com.aol.cyclops.types.Traversable<T>
 - zip4
```
default <T2,T3,T4> FluxT<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<? extends T2> second,
 java.util.stream.Stream<? extends T3> third,
 java.util.stream.Stream<? extends T4> fourth)
```
 Specified by:
 
 zip4 in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zip4 in interface com.aol.cyclops.types.Traversable<T>
 - zipWithIndex
```
default FluxT<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 zipWithIndex in interface com.aol.cyclops.types.Traversable<T>
 - sliding
```
default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> sliding(int windowSize)
```
 Specified by:
 
 sliding in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.types.Traversable<T>
 - sliding
```
default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> sliding(int windowSize,
 int increment)
```
 Specified by:
 
 sliding in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 sliding in interface com.aol.cyclops.types.Traversable<T>
 - grouped
```
default <C extends java.util.Collection<? super T>> FluxT<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 - groupedUntil
```
default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.types.Traversable<T>
 - groupedStatefullyUntil
```
default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<com.aol.cyclops.data.collections.extensions.standard.ListX<? super T>,? super T> predicate)
```
 Specified by:
 
 groupedStatefullyUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface com.aol.cyclops.types.Traversable<T>
 - groupedWhile
```
default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.types.Traversable<T>
 - groupedWhile
```
default <C extends java.util.Collection<? super T>> FluxT<C> groupedWhile(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 groupedWhile in interface com.aol.cyclops.types.Traversable<T>
 - groupedUntil
```
default <C extends java.util.Collection<? super T>> FluxT<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 groupedUntil in interface com.aol.cyclops.types.Traversable<T>
 - grouped
```
default FluxT<com.aol.cyclops.data.collections.extensions.standard.ListX<T>> grouped(int groupSize)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 - grouped
```
default <K,A,D> FluxT<org.jooq.lambda.tuple.Tuple2<K,D>> grouped(java.util.function.Function<? super T,? extends K> classifier,
 java.util.stream.Collector<? super T,A,D> downFlux)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 - grouped
```
default <K> FluxT<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>> grouped(java.util.function.Function<? super T,? extends K> classifier)
```
 Specified by:
 
 grouped in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 grouped in interface com.aol.cyclops.types.Traversable<T>
 - distinct
```
default FluxT<T> distinct()
```
 Specified by:
 
 distinct in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 distinct in interface com.aol.cyclops.types.Traversable<T>
 - scanLeft
```
default FluxT<T> scanLeft(com.aol.cyclops.Monoid<T> monoid)
```
 Specified by:
 
 scanLeft in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.types.Traversable<T>
 - scanLeft
```
default  FluxT scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Specified by:
 
 scanLeft in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 scanLeft in interface com.aol.cyclops.types.Traversable<T>
 - scanRight
```
default FluxT<T> scanRight(com.aol.cyclops.Monoid<T> monoid)
```
 Specified by:
 
 scanRight in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.types.Traversable<T>
 - scanRight
```
default  FluxT scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Specified by:
 
 scanRight in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 scanRight in interface com.aol.cyclops.types.Traversable<T>
 - sorted
```
default FluxT<T> sorted()
```
 Specified by:
 
 sorted in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.types.Traversable<T>
 - sorted
```
default FluxT<T> sorted(java.util.Comparator<? super T> c)
```
 Specified by:
 
 sorted in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.types.Traversable<T>
 - takeWhile
```
default FluxT<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 takeWhile in interface com.aol.cyclops.types.Traversable<T>
 - dropWhile
```
default FluxT<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 dropWhile in interface com.aol.cyclops.types.Traversable<T>
 - takeUntil
```
default FluxT<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 takeUntil in interface com.aol.cyclops.types.Traversable<T>
 - dropUntil
```
default FluxT<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 dropUntil in interface com.aol.cyclops.types.Traversable<T>
 - dropRight
```
default FluxT<T> dropRight(int num)
```
 Specified by:
 
 dropRight in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 dropRight in interface com.aol.cyclops.types.Traversable<T>
 - takeRight
```
default FluxT<T> takeRight(int num)
```
 Specified by:
 
 takeRight in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 takeRight in interface com.aol.cyclops.types.Traversable<T>
 - skip
```
default FluxT<T> skip(long num)
```
 Specified by:
 
 skip in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 skip in interface com.aol.cyclops.types.Traversable<T>
 - skipWhile
```
default FluxT<T> skipWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 skipWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 skipWhile in interface com.aol.cyclops.types.Traversable<T>
 - skipUntil
```
default FluxT<T> skipUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 skipUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 skipUntil in interface com.aol.cyclops.types.Traversable<T>
 - limit
```
default FluxT<T> limit(long num)
```
 Specified by:
 
 limit in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 limit in interface com.aol.cyclops.types.Traversable<T>
 - limitWhile
```
default FluxT<T> limitWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 limitWhile in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 limitWhile in interface com.aol.cyclops.types.Traversable<T>
 - limitUntil
```
default FluxT<T> limitUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 limitUntil in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 limitUntil in interface com.aol.cyclops.types.Traversable<T>
 - intersperse
```
default FluxT<T> intersperse(T value)
```
 Specified by:
 
 intersperse in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 intersperse in interface com.aol.cyclops.types.Traversable<T>
 - reverse
```
default FluxT<T> reverse()
```
 Specified by:
 
 reverse in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 reverse in interface com.aol.cyclops.types.Traversable<T>
 - shuffle
```
default FluxT<T> shuffle()
```
 Specified by:
 
 shuffle in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.types.Traversable<T>
 - skipLast
```
default FluxT<T> skipLast(int num)
```
 Specified by:
 
 skipLast in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 skipLast in interface com.aol.cyclops.types.Traversable<T>
 - limitLast
```
default FluxT<T> limitLast(int num)
```
 Specified by:
 
 limitLast in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 limitLast in interface com.aol.cyclops.types.Traversable<T>
 - onEmpty
```
default FluxT<T> onEmpty(T value)
```
 Specified by:
 
 onEmpty in interface com.aol.cyclops.types.OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 onEmpty in interface com.aol.cyclops.types.Traversable<T>
 - onEmptyGet
```
default FluxT<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.types.OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 onEmptyGet in interface com.aol.cyclops.types.Traversable<T>
 - onEmptyThrow
```
default <X extends java.lang.Throwable> FluxT<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.types.OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 onEmptyThrow in interface com.aol.cyclops.types.Traversable<T>
 - shuffle
```
default FluxT<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 shuffle in interface com.aol.cyclops.types.Traversable<T>
 - slice
```
default FluxT<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 slice in interface com.aol.cyclops.types.Traversable<T>
 - sorted
```
default > FluxT<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq<T>
 
 Specified by:
 
 sorted in interface com.aol.cyclops.types.Traversable<T>

Interface FluxT<T>

Method Summary

Methods inherited from interface com.aol.cyclops.control.monads.transformers.values.FoldableTransformerSeq

Methods inherited from interface com.aol.cyclops.control.monads.transformers.values.TransformerSeq

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

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

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

Methods inherited from interface java.lang.Iterable

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

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

Methods inherited from interface com.aol.cyclops.types.anyM.NestedFoldable

Methods inherited from interface com.aol.cyclops.types.anyM.NestedCollectable

Method Detail

unitIterator

unit

empty

flatMap

fluxOfFlux

unwrap

peek

filter

map

bind

lift

fromAnyM

of

fromAnyMValue

fromAnyMSeq

fromIterable

fromPublisher

fromValue

fromOptional

fromFuture

fromMono

fromIterableValue

emptyOptional

emptyFlux

flux

cast

trampoline

patternMatch

ofType

filterNot

notNull

combine

cycle

cycle

cycleWhile

cycleUntil

zip

zip

zip

zip

zip

zip

zip3

zip4

zipWithIndex

sliding

sliding

grouped

groupedUntil

groupedStatefullyUntil

groupedWhile

groupedWhile

groupedUntil

grouped

grouped

grouped

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

sorted

takeWhile

dropWhile

takeUntil

dropUntil