FluxT (cyclops-reactor 8.4.2 API)

Type Parameters:

T - the type of elements held in the nested Fluxes

All Superinterfaces:

ConvertableSequence<T>, ConvertableToReactiveSeq<T>, Filterable<T>, FilterableFunctor<T>, FoldableTransformerSeq<T>, Functor<T>, java.lang.Iterable<T>, NestedCollectable<T>, NestedFoldable<T>, OnEmpty<T>, org.reactivestreams.Publisher<T>, Sequential<T>, ToStream<T>, TransformerSeq<T>, Traversable<T>, Zippable<T>

All Known Implementing Classes:

FluxTSeq, FluxTValue
```
public interface FluxT<T>
extends 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)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default FluxT<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`default FluxT<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default FluxT<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default FluxT<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default FluxT<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default FluxT<T>`	`distinct()`
`default FluxT<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the end of this Traversable
`default FluxT<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`default FluxT<T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`<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)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<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(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(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(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 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)` Group this Traversable by the provided classifying function and collected by the provided Collector
`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)` Group this Traversable by the provided classifying function and collected by the provided Collector
`default FluxT<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> FluxT<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Batch elements in a Stream by size into a collection created by the supplied factory
`default FluxT<ListX<T>>`	`groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`default FluxT<ListX<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated until the predicate holds
`default <C extends java.util.Collection<? super T>> FluxT<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`default FluxT<ListX<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated while the predicate holds
`default <C extends java.util.Collection<? super T>> FluxT<C>`	`groupedWhile(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
`default FluxT<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`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)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default FluxT<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default FluxT<T>`	`limitUntil(java.util.function.Predicate<? super T> p)` Take elements from the Stream until the predicate returns true, after which all elements are excluded.
`default FluxT<T>`	`limitWhile(java.util.function.Predicate<? super T> p)` Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
`<B> FluxT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Flux
`default FluxT<T>`	`notNull()` Filter elements retaining only values which are not null
`static <A> FluxT<A>`	`of(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)` Keep only those elements in a stream that are of a given type.
`default FluxT<T>`	`onEmpty(T value)` If this Container instance is empty, create a new instance containing the provided value
`default FluxT<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
`default <X extends java.lang.Throwable> FluxT<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)` If this container instance is empty, throw the exception returned by the provided Supplier
`default <R> FluxT<R>`	`patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,R>> case1, java.util.function.Supplier<? extends R> otherwise)` Transform the elements of this Stream with a Pattern Matching case and default value
`FluxT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Flux
`default FluxT<T>`	`reverse()` Potentially efficient Stream reversal.
`default FluxT<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> FluxT<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default FluxT<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> FluxT<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default FluxT<T>`	`shuffle()`
`default FluxT<T>`	`shuffle(java.util.Random random)`
`default FluxT<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default FluxT<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default FluxT<T>`	`skipUntil(java.util.function.Predicate<? super T> p)` Drop elements from the Stream until the predicate returns true, after which all elements are included
`default FluxT<T>`	`skipWhile(java.util.function.Predicate<? super T> p)` SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
`default FluxT<T>`	`slice(long from, long to)`
`default FluxT<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default FluxT<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default FluxT<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default FluxT<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`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)` Generate a new Traversable that takes the specified number elements from the end of this Traversable
`default FluxT<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`default FluxT<T>`	`takeWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`default <R> FluxT<R>`	`trampoline(java.util.function.Function<? super T,? extends Trampoline<? extends R>> mapper)` Performs a map operation that can call a recursive method without running out of stack space
`<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.
`AnyM<reactor.core.publisher.Flux<T>>`	`unwrap()`
`default <U> FluxT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)` Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
`default <U,R> FluxT<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`default <U> FluxT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
`default <U,R> FluxT<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
`default <U> FluxT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`default <U,R> FluxT<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
`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)` zip 3 Streams into one
`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)` zip 4 Streams into 1
`default FluxT<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

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
drop, take, 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
```
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 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 Filterable<T>
 
 Specified by:
 
 filter in interface 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 FilterableFunctor<T>
 
 Specified by:
 
 map in interface 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(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(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(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(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 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)
```
 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<T>
 - trampoline
```
default <R> FluxT<R> trampoline(java.util.function.Function<? super T,? 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<T>
 
 Parameters:
 
 mapper - TCO Transformation function
 
 Returns:
 
 Functor transformed by the supplied transformation function
 - patternMatch
```
default <R> FluxT<R> patternMatch(java.util.function.Function<Matchable.CheckValue1<T,R>,Matchable.CheckValue1<T,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<T>
 
 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  FluxT 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<T>
 - filterNot
```
default FluxT<T> filterNot(java.util.function.Predicate<? super T> 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<T>
 
 Parameters:
 
 fn - to filter elements by, retaining matches
 
 Returns:
 
 Filterable with elements removed where the predicate does not hold
 - notNull
```
default FluxT<T> 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<T>
 
 Returns:
 
 Filterable with nulls removed
 - combine
```
default FluxT<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The output of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),Semigroups.intSum)
 .toListX()
 
 //ListX(3,4) 
 
```
 Specified by:
 
 combine in interface TransformerSeq<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined
 
 op - Reducer to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - cycle
```
default FluxT<T> cycle(int times)
```
 Description copied from interface: Traversable
 Convert to a Stream with the values repeated specified times
```
 
 		ReactiveSeq.of(1,2,2)
 								.cycle(3)
 								.collect(Collectors.toList());
 								
 		//List[1,2,2,1,2,2,1,2,2]
 
 
 
```
 Specified by:
 
 cycle in interface TransformerSeq<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 times - Times values should be repeated within a Stream
 
 Returns:
 
 Stream with values repeated
 - cycle
```
default FluxT<T> cycle(Monoid<T> m,
 int times)
```
 Description copied from interface: Traversable
 Convert to a Stream with the result of a reduction operation repeated specified times
```
 
 List<Integer> list = ReactiveSeq.of(1,2,2))
 .cycle(Reducers.toCountInt(),3)
 .collect(Collectors.toList());
 //List[3,3,3];
 
 
```
 Specified by:
 
 cycle in interface TransformerSeq<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Parameters:
 
 m - Monoid to be used in reduction
 
 times - Number of times value should be repeated
 
 Returns:
 
 Stream with reduced values repeated
 - cycleWhile
```
default FluxT<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 
 MutableInt count = MutableInt.of(0);
 ReactiveSeq.of(1, 2, 2).cycleWhile(next -> count++ < 6).collect(Collectors.toList());
 
 // List(1,2,2,1,2,2)
 
 
```
 Specified by:
 
 cycleWhile in interface TransformerSeq<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
default FluxT<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream until specified predicate holds
```
 
 	MutableInt count =MutableInt.of(0);
 		ReactiveSeq.of(1,2,2)
 		 		.cycleUntil(next -> count.get()>6)
 		 		.peek(i-> count.mutate(i->i+1))
 		 		.collect(Collectors.toList());
 
 		//List[1,2,2,1,2,2,1]	
 
 
```
 Specified by:
 
 cycleUntil in interface TransformerSeq<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
default <U,R> FluxT<R> zip(java.lang.Iterable<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - 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)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq, using the supplied combining function
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - 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)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Stream, using the supplied combining function
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 zipper - Zip / combining function
 
 Returns:
 
 Combined zippable
 - zip
```
default  FluxT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 

 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 
 
```
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Stream to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default  FluxT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Seq combining both into a Tuple2
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Seq to combine with
 
 Returns:
 
 Combined Zippable
 - zip
```
default  FluxT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable combining both into a Tuple2
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Parameters:
 
 other - Iterable to combine with
 
 Returns:
 - 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)
```
 Description copied from interface: Traversable
 zip 3 Streams into one
```
 
 List<Tuple3<Integer, Integer, Character>> list = of(1, 2, 3, 4, 5, 6).zip3(of(100, 200, 300, 400), of('a', 'b', 'c')).collect(Collectors.toList());
 
 // [[1,100,'a'],[2,200,'b'],[3,300,'c']]
 
 
 
```
 Specified by:
 
 zip3 in interface TransformerSeq<T>
 
 Specified by:
 
 zip3 in interface 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)
```
 Description copied from interface: Traversable
 zip 4 Streams into 1
```
 
 List<Tuple4<Integer, Integer, Character, String>> list = of(1, 2, 3, 4, 5, 6).zip4(of(100, 200, 300, 400), of('a', 'b', 'c'), of("hello", "world"))
 .collect(Collectors.toList());
 
 
 // [[1,100,'a',"hello"],[2,200,'b',"world"]]
 
```
 Specified by:
 
 zip4 in interface TransformerSeq<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 - zipWithIndex
```
default FluxT<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Description copied from interface: Traversable
 Add an index to the current Stream
```
 
 assertEquals(asList(new Tuple2("a", 0L), new Tuple2("b", 1L)), of("a", "b").zipWithIndex().toList());
 
 
```
 Specified by:
 
 zipWithIndex in interface TransformerSeq<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - sliding
```
default FluxT<ListX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2));
 assertThat(list.get(1), hasItems(2, 3));
 
 
 
 
```
 Specified by:
 
 sliding in interface TransformerSeq<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - Size of sliding window
 
 Returns:
 
 SequenceM with sliding view
 - sliding
```
default FluxT<ListX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(3, 4, 5)); 
 
 
 
 
 
```
 Specified by:
 
 sliding in interface TransformerSeq<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Parameters:
 
 windowSize - number of elements in each batch
 
 increment - for each window
 
 Returns:
 
 SequenceM with sliding view
 - grouped
```
default <C extends java.util.Collection<? super T>> FluxT<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 Batch elements in a Stream by size into a collection created by the supplied factory
```
 
 assertThat(ReactiveSeq.of(1,1,1,1,1,1)
 .batchBySize(3,()->new TreeSet<>())
 .toList()
 .get(0)
 .size(),is(1));
 
 
```
 Specified by:
 
 grouped in interface TransformerSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 SequenceM batched into collection types by size
 - groupedUntil
```
default FluxT<ListX<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3==0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface TransformerSeq<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedStatefullyUntil
```
default FluxT<ListX<T>> groupedStatefullyUntil(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)
```
 Description copied from interface: Traversable
 Create Travesable of Lists where each List is populated while the supplied bipredicate holds. The bipredicate recieves the List from the last window as well as the current value and can choose to aggregate the current value or create a new window
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedStatefullyUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyUntil in interface TransformerSeq<T>
 
 Specified by:
 
 groupedStatefullyUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - groupedWhile
```
default FluxT<ListX<T>> groupedWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Create a Traversable batched by List, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .groupedWhile(i->i%3!=0)
 .toList().size(),equalTo(2));
 
 
 
```
 Specified by:
 
 groupedWhile in interface TransformerSeq<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - 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)
```
 Description copied from interface: Traversable
 Create a SequenceM batched by a Collection, where each batch is populated while the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchWhile(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedWhile in interface TransformerSeq<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - 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)
```
 Description copied from interface: Traversable
 Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3!=0)
 .toList()
 
 //2
 
 
```
 Specified by:
 
 groupedUntil in interface TransformerSeq<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, then open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - grouped
```
default FluxT<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList());
 
 assertThat(list.get(0), hasItems(1, 2, 3));
 assertThat(list.get(1), hasItems(4, 5, 6));
 
 
 
```
 Specified by:
 
 grouped in interface TransformerSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - 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)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface TransformerSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 downFlux - Collector to create the grouping collection
 
 Returns:
 
 Traversable of grouped data
 - 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)
```
 Description copied from interface: Traversable
 
 Group this Traversable by the provided classifying function and collected by the provided Collector
 
 Specified by:
 
 grouped in interface TransformerSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Parameters:
 
 classifier - Grouping function
 
 Returns:
 
 Traversable of grouped data
 - distinct
```
default FluxT<T> distinct()
```
 Specified by:
 
 distinct in interface TransformerSeq<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - scanLeft
```
default FluxT<T> scanLeft(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan left using supplied Monoid
```
 
 
 	assertEquals(asList("", "a", "ab", "abc"),ReactiveSeq.of("a", "b", "c")
 													.scanLeft(Reducers.toString("")).toList());
 
 
 
```
 Specified by:
 
 scanLeft in interface TransformerSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanLeft
```
default  FluxT scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Description copied from interface: Traversable
 Scan left
```
 
 assertThat(of("a", "b", "c").scanLeft("", String::concat).toList().size(),
 		is(4));
 
 
```
 Specified by:
 
 scanLeft in interface TransformerSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
default FluxT<T> scanRight(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan right
```
 
 assertThat(of("a", "b", "c").scanRight(Monoid.of("", String::concat)).toList().size(),
 is(asList("", "c", "bc", "abc").size()));
 
 
```
 Specified by:
 
 scanRight in interface TransformerSeq<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
default  FluxT scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Description copied from interface: Traversable
 Scan right
```
 
 assertThat(of("a", "ab", "abc").map(str->str.length()).scanRight(0, (t, u) -> u + t).toList().size(),
 is(asList(0, 3, 5, 6).size()));
 
 
 
```
 Specified by:
 
 scanRight in interface TransformerSeq<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - sorted
```
default FluxT<T> sorted()
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7))); 
 
```
 Specified by:
 
 sorted in interface TransformerSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
default FluxT<T> sorted(java.util.Comparator<? super T> c)
```
 Description copied from interface: Traversable
```
 
 	assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));
 
 
```
 Specified by:
 
 sorted in interface TransformerSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeWhile
```
default FluxT<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface TransformerSeq<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropWhile
```
default FluxT<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
```
 
 ListX.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface TransformerSeq<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeUntil
```
default FluxT<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface TransformerSeq<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropUntil
```
default FluxT<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 ListX.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface TransformerSeq<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropRight
```
default FluxT<T> dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface TransformerSeq<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Parameters:
 
 num - Drop this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeRight
```
default FluxT<T> takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the end of this Traversable
```
 
 ListX.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface TransformerSeq<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Parameters:
 
 num - Take this number of elements from the end of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - skip
```
default FluxT<T> skip(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 skip in interface TransformerSeq<T>
 
 Specified by:
 
 skip in interface Traversable<T>
 
 Parameters:
 
 num - Number of elemenets to skip
 
 Returns:
 
 Stream with specified number of elements skipped
 - skipWhile
```
default FluxT<T> skipWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 SkipWhile drops elements from the Stream while the predicate holds, once the predicte returns true all subsequent elements are included *
```
 
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().skipWhile(i->i<6).toList(),equalTo(Arrays.asList(6,7)));
 
 
```
 Specified by:
 
 skipWhile in interface TransformerSeq<T>
 
 Specified by:
 
 skipWhile in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip while true
 
 Returns:
 
 Stream with elements skipped while predicate holds
 - skipUntil
```
default FluxT<T> skipUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Drop elements from the Stream until the predicate returns true, after which all elements are included
```
 assertThat(ReactiveSeq.of(4,3,6,7).skipUntil(i->i==6).toList(),equalTo(Arrays.asList(6,7)));
 
```
 Specified by:
 
 skipUntil in interface TransformerSeq<T>
 
 Specified by:
 
 skipUntil in interface Traversable<T>
 
 Parameters:
 
 p - Predicate to skip until true
 
 Returns:
 
 Stream with elements skipped until predicate holds
 - limit
```
default FluxT<T> limit(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));
 
```
 Specified by:
 
 limit in interface TransformerSeq<T>
 
 Specified by:
 
 limit in interface Traversable<T>
 
 Parameters:
 
 num - Limit element size to num
 
 Returns:
 
 Monad converted to Stream with elements up to num
 - limitWhile
```
default FluxT<T> limitWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Take elements from the Stream while the predicate holds, once the predicate returns false all subsequent elements are excluded
```
 assertThat(ReactiveSeq.of(4,3,6,7).sorted().limitWhile(i->i<6).toList(),equalTo(Arrays.asList(3,4)));
 
```
 Specified by:
 
 limitWhile in interface TransformerSeq<T>
 
 Specified by:
 
 limitWhile in interface Traversable<T>
 
 Parameters:
 
 p - Limit while predicate is true
 
 Returns:
 
 Stream with limited elements
 - limitUntil
```
default FluxT<T> limitUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Take elements from the Stream until the predicate returns true, after which all elements are excluded.
```
 assertThat(ReactiveSeq.of(4,3,6,7).limitUntil(i->i==6).toList(),equalTo(Arrays.asList(4,3))); 
 
```
 Specified by:
 
 limitUntil in interface TransformerSeq<T>
 
 Specified by:
 
 limitUntil in interface Traversable<T>
 
 Parameters:
 
 p - Limit until predicate is true
 
 Returns:
 
 Stream with limited elements
 - intersperse
```
default FluxT<T> intersperse(T value)
```
 Description copied from interface: Traversable
 
 Returns a stream with a given value interspersed between any two values of this stream. // (1, 0, 2, 0, 3, 0, 4) ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 
 Specified by:
 
 intersperse in interface TransformerSeq<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - reverse
```
default FluxT<T> reverse()
```
 Description copied from interface: Traversable
 Potentially efficient Stream reversal. Is efficient if - Sequence created via a range - Sequence created via a List - Sequence created via an Array / var args Otherwise Sequence collected into a Collection prior to reversal
```
 assertThat( of(1, 2, 3).reverse().toList(),
 equalTo(asList(3, 2, 1))); 
```
 Specified by:
 
 reverse in interface TransformerSeq<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - shuffle
```
default FluxT<T> shuffle()
```
 Specified by:
 
 shuffle in interface TransformerSeq<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
default FluxT<T> skipLast(int num)
```
 Description copied from interface: Traversable
 
 assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
 
 Specified by:
 
 skipLast in interface TransformerSeq<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
default FluxT<T> limitLast(int num)
```
 Description copied from interface: Traversable
 Limit results to the last x elements in a SequenceM
```
 
 	assertThat(ReactiveSeq.of(1,2,3,4,5)
 							.limitLast(2)
 							.collect(Collectors.toList()),equalTo(Arrays.asList(4,5)));
 
 
 
```
 Specified by:
 
 limitLast in interface TransformerSeq<T>
 
 Specified by:
 
 limitLast in interface Traversable<T>
 
 Parameters:
 
 num - of elements to return (last elements)
 
 Returns:
 
 SequenceM limited to last num elements
 - onEmpty
```
default FluxT<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface TransformerSeq<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Returns:
 
 New instance containing value if container is empty, otherwise returns this container
 - onEmptyGet
```
default FluxT<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is empty, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface TransformerSeq<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is empty, otherwise this container
 - onEmptyThrow
```
default <X extends java.lang.Throwable> FluxT<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Description copied from interface: OnEmpty
 
 If this container instance is empty, throw the exception returned by the provided Supplier
 
 Specified by:
 
 onEmptyThrow in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyThrow in interface TransformerSeq<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 
 Parameters:
 
 supplier - to create exception from
 
 Returns:
 
 Throw exception if empty, otherwise this container
 - shuffle
```
default FluxT<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface TransformerSeq<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - slice
```
default FluxT<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface TransformerSeq<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - sorted
```
default > FluxT<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface TransformerSeq<T>
 
 Specified by:
 
 sorted in interface 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