ListTSeq (simple-react 1.0.0-RC3 API)

java.lang.Object
- com.aol.cyclops.control.monads.transformers.seq.ListTSeq<T>

Type Parameters:

T -

All Implemented Interfaces:

ListT<T>, FoldableTransformerSeq<T>, TransformerSeq<T>, NestedCollectable<T>, NestedFoldable<T>, Filterable<T>, FilterableFunctor<T>, Functor<T>, Sequential<T>, ConvertableSequence<T>, ConvertableToReactiveSeq<T>, ToStream<T>, Traversable<T>, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>
```
public class ListTSeq<T>
extends java.lang.Object
implements ListT<T>
```
Monad Transformer for Java Lists ListT consists of an AnyM instance that in turns wraps anoter Monad type that contains an List ListT>>> ListT allows the deeply wrapped List to be manipulating within it's nested /contained context

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ListTSeq<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 & reduction operation.
`ListTSeq<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`ListTSeq<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`ListTSeq<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`ListTSeq<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`ListTSeq<T>`	`distinct()`
`ListTSeq<T>`	`dropRight(int num)`
`ListTSeq<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`ListTSeq<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`<R> ListT<R>`	`empty()`
`static <T> ListTSeq<T>`	`emptyList()`
`ListTSeq<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped List
`<B> ListTSeq<B>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)`
`<B> ListTSeq<B>`	`flatMapT(java.util.function.Function<? super T,ListTSeq<B>> f)` Flat Map the wrapped List
`static <A> ListTSeq<A>`	`fromAnyM(AnyMSeq<A> anyM)` Construct an ListT from an AnyM that contains a monad type that contains type other than List The values in the underlying monad will be mapped to List
`static <A> ListTSeq<A>`	`fromStream(AnyMSeq<java.util.stream.Stream<A>> monads)` Create a ListT from an AnyM that wraps a monad containing a Stream
`<K> ListTSeq<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`<K,A,D> ListTSeq<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> downstream)`
`ListTSeq<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends java.util.Collection<? super T>> ListTSeq<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
`ListTSeq<ListX<T>>`	`groupedStatefullyWhile(java.util.function.BiPredicate<ListX<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`ListTSeq<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
`<C extends java.util.Collection<? super T>> ListTSeq<C>`	`groupedUntil(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 until the predicate holds
`ListTSeq<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
`<C extends java.util.Collection<? super T>> ListTSeq<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
`ListTSeq<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`boolean`	`isSeqPresent()`
`java.util.Iterator<T>`	`iterator()`
`static <U,R> java.util.function.Function<ListTSeq<U>,ListTSeq<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an ListT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R> java.util.function.BiFunction<ListTSeq<U1>,ListTSeq<U2>,ListTSeq<R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns ListTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`ListTSeq<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`ListTSeq<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`ListTSeq<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.
`ListTSeq<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> ListTSeq<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped List
`AnyM<? extends CyclopsCollectable<T>>`	`nestedCollectables()`
`AnyM<? extends Foldable<T>>`	`nestedFoldables()`
`static <A> ListTSeq<A>`	`of(AnyMSeq<? extends java.util.List<A>> monads)` Construct an ListT from an AnyM that wraps a monad containing Lists
`static <A> ListTSeq<A>`	`of(java.util.List<A> monads)`
`ListTSeq<T>`	`onEmpty(T value)`
`ListTSeq<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`<X extends java.lang.Throwable> ListTSeq<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`ListTSeq<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the List
`ListTSeq<T>`	`reverse()`
`ListTSeq<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> ListTSeq<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`ListTSeq<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> ListTSeq<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`ListTSeq<T>`	`shuffle()`
`ListTSeq<T>`	`shuffle(java.util.Random random)`
`ListTSeq<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`ListTSeq<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`ListTSeq<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
`ListTSeq<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 *
`ListTSeq<T>`	`slice(long from, long to)`
`ListTSeq<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`ListTSeq<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`ListTSeq<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`ListTSeq<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)));`
`<U extends java.lang.Comparable<? super U>> ListTSeq<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`ReactiveSeq<T>`	`stream()`
`ListTSeq<T>`	`takeRight(int num)`
`ListTSeq<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`ListTSeq<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`java.lang.String`	`toString()`
`AnyMSeq<? extends Traversable<T>>`	`transformerStream()`
`<T> ListTSeq<T>`	`unit(T unit)`
`<T> ListTSeq<T>`	`unitAnyM(AnyM<Traversable<T>> traversable)`
`<R> ListTSeq<R>`	`unitIterator(java.util.Iterator<R> it)`
`AnyMSeq<ListX<T>>`	`unwrap()`
`<U,R> ListTSeq<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`<U> ListTSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)` Zip 2 streams into one
`<S,U> ListTSeq<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
`<T2,T3,T4> ListTSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>>`	`zip4(java.util.stream.Stream<T2> second, java.util.stream.Stream<T3> third, java.util.stream.Stream<T4> fourth)` zip 4 Streams into 1
`<U> ListTSeq<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zipStream(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`ListTSeq<org.jooq.lambda.tuple.Tuple2<T,java.lang.Long>>`	`zipWithIndex()` Add an index to the current Stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops.control.monads.transformers.ListT
bind, cast, emptyOptional, filterNot, fromAnyM, fromAnyMSeq, fromAnyMValue, fromFuture, fromIterable, fromIterablListue, fromOptional, fromPublisher, fromStream, fromStreamAnyM, fromValue, notNull, of, ofType, patternMatch, trampoline

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

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.Sequential
fixedDelay, onePer, xPer

Methods inherited from interface com.aol.cyclops.types.stream.ToStream
futureStream, getStreamable, isEmpty, 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, print, print, printErr, printOut, reduce, reduce, reduce, reduce, reduce, reduce, schedule, scheduleFixedDelay, scheduleFixedRate, single, single, singleOptional, startsWith, startsWithIterable, toConcurrentLazyCollection, toConcurrentLazyStreamable, toLazyCollection, validate, visit, visit

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

- Method Detail
 - unwrap
```
public AnyMSeq<ListX<T>> unwrap()
```
 Specified by:
 
 unwrap in interface ListT<T>
 
 Returns:
 
 The wrapped AnyM
 - peek
```
public ListTSeq<T> peek(java.util.function.Consumer<? super T> peek)
```
 Peek at the current value of the List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10))
 .peek(System.out::println);
 
 //prints 10 
 
 
```
 Specified by:
 
 peek in interface ListT<T>
 
 Specified by:
 
 peek in interface Functor<T>
 
 Parameters:
 
 peek - Consumer to accept current value of List
 
 Returns:
 
 ListT with peek call
 - filter
```
public ListTSeq<T> filter(java.util.function.Predicate<? super T> test)
```
 Filter the wrapped List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10,11))
 .filter(t->t!=10);
 
 //ListT<AnyM<Stream<List[11]>>>
 
 
```
 Specified by:
 
 filter in interface ListT<T>
 
 Specified by:
 
 filter in interface Filterable<T>
 
 Specified by:
 
 filter in interface FilterableFunctor<T>
 
 Parameters:
 
 test - Predicate to filter the wrapped List
 
 Returns:
 
 ListT that applies the provided filter
 - map
```
public  ListTSeq map(java.util.function.Function<? super T,? extends B> f)
```
 Map the wrapped List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10))
 .map(t->t=t+1);
 
 
 //ListT<AnyM<Stream<List[11]>>>
 
 
```
 Specified by:
 
 map in interface ListT<T>
 
 Specified by:
 
 map in interface FilterableFunctor<T>
 
 Specified by:
 
 map in interface Functor<T>
 
 Parameters:
 
 f - Mapping function for the wrapped List
 
 Returns:
 
 ListT that applies the map function to the wrapped List
 - flatMap
```
public  ListTSeq flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)
```
 Specified by:
 
 flatMap in interface ListT<T>
 - flatMapT
```
public  ListTSeq flatMapT(java.util.function.Function<? super T,ListTSeq> f)
```
 Flat Map the wrapped List
```
 
 ListT.of(AnyM.fromStream(Arrays.asList(10))
 .flatMap(t->List.empty();
 
 
 //ListT<AnyM<Stream<List.empty>>>
 
 
```
 Parameters:
 
 f - FlatMap function
 
 Returns:
 
 ListT that applies the flatMap function to the wrapped List
 - lift
```
public static <U,R> java.util.function.Function<ListTSeq,ListTSeq<R>> lift(java.util.function.Function<? super U,? extends R> fn)
```
 Lift a function into one that accepts and returns an ListT This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling (via List) and iteration (via Stream) to an existing function
```
 
 Function<Integer,Integer> add2 = i -> i+2;
		Function<ListT<Integer>, ListT<Integer>> optTAdd2 = ListT.lift(add2);
		
		Stream<Integer> nums = Stream.of(1,2);
		AnyM<Stream<Integer>> stream = AnyM.ofMonad(Arrays.asList(nums));
		
		List<Integer> results = optTAdd2.apply(ListT.fromStream(stream))
										.unwrap()
										.<Optional<List<Integer>>>unwrap().get();
		
		
		//Arrays.asList(3,4);
 
 
 
```
 Specified by:
 
 lift in interface ListT<T>
 
 Parameters:
 
 fn - Function to enhance with functionality from List and another monad type
 
 Returns:
 
 Function that accepts and returns an ListT
 - lift2
```
public static <U1,U2,R> java.util.function.BiFunction<ListTSeq<U1>,ListTSeq<U2>,ListTSeq<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)
```
 Lift a BiFunction into one that accepts and returns ListTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling (via List), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function
```
 
BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
		BiFunction<ListT<Integer>,ListT<Integer>, ListT<Integer>> optTAdd2 = ListT.lift2(add);
		
		Streamable<Integer> threeValues = Streamable.of(1,2,3);
		AnyM<Integer> stream = AnyM.fromStreamable(threeValues);
		AnyM<List<Integer>> streamOpt = stream.map(Arrays::asList);
		
		CompletableFuture<List<Integer>> two = CompletableFuture.completedFuture(Arrays.asList(2));
		AnyM<List<Integer>> future= AnyM.fromCompletableFuture(two);
		List<Integer> results = optTAdd2.apply(ListT.of(streamOpt),ListT.of(future))
										.unwrap()
										.<Stream<List<Integer>>>unwrap()
										.flatMap(i->i.stream())
										.collect(Collectors.toList());
			//Arrays.asList(3,4);							
	 
 
```
 Specified by:
 
 lift2 in interface ListT<T>
 
 Parameters:
 
 fn - BiFunction to enhance with functionality from List and another monad type
 
 Returns:
 
 Function that accepts and returns an ListT
 - fromAnyM
```
public static <A> ListTSeq<A> fromAnyM(AnyMSeq<A> anyM)
```
 Construct an ListT from an AnyM that contains a monad type that contains type other than List The values in the underlying monad will be mapped to List
 
 Parameters:
 
 anyM - AnyM that doesn't contain a monad wrapping an List
 
 Returns:
 
 ListT
 - of
```
public static <A> ListTSeq<A> of(AnyMSeq<? extends java.util.List<A>> monads)
```
 Construct an ListT from an AnyM that wraps a monad containing Lists
 
 Parameters:
 
 monads - AnyM that contains a monad wrapping an List
 
 Returns:
 
 ListT
 - of
```
public static <A> ListTSeq<A> of(java.util.List<A> monads)
```
 - fromStream
```
public static <A> ListTSeq<A> fromStream(AnyMSeq<java.util.stream.Stream<A>> monads)
```
 Create a ListT from an AnyM that wraps a monad containing a Stream
 
 Parameters:
 
 monads -
 
 Returns:
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - unit
```
public <T> ListTSeq<T> unit(T unit)
```
 Specified by:
 
 unit in interface ListT<T>
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface FoldableTransformerSeq<T>
 
 Specified by:
 
 stream in interface TransformerSeq<T>
 
 Specified by:
 
 stream in interface NestedFoldable<T>
 
 Specified by:
 
 stream in interface Sequential<T>
 
 Specified by:
 
 stream in interface ConvertableSequence<T>
 
 Specified by:
 
 stream in interface ToStream<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Returns:
 
 SequenceM from this Streamable
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface ToStream<T>
 
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - unitIterator
```
public <R> ListTSeq<R> unitIterator(java.util.Iterator<R> it)
```
 Specified by:
 
 unitIterator in interface ListT<T>
 - empty
```
public <R> ListT<R> empty()
```
 Specified by:
 
 empty in interface ListT<T>
 - nestedFoldables
```
public AnyM<? extends Foldable<T>> nestedFoldables()
```
 Specified by:
 
 nestedFoldables in interface NestedFoldable<T>
 - nestedCollectables
```
public AnyM<? extends CyclopsCollectable<T>> nestedCollectables()
```
 Specified by:
 
 nestedCollectables in interface NestedCollectable<T>
 - unitAnyM
```
public <T> ListTSeq<T> unitAnyM(AnyM<Traversable<T>> traversable)
```
 Specified by:
 
 unitAnyM in interface TransformerSeq<T>
 - transformerStream
```
public AnyMSeq<? extends Traversable<T>> transformerStream()
```
 Specified by:
 
 transformerStream in interface TransformerSeq<T>
 - emptyList
```
public static <T> ListTSeq<T> emptyList()
```
 Specified by:
 
 emptyList in interface ListT<T>
 - isSeqPresent
```
public boolean isSeqPresent()
```
 Specified by:
 
 isSeqPresent in interface ListT<T>
 
 Specified by:
 
 isSeqPresent in interface TransformerSeq<T>
 - combine
```
public ListTSeq<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 & 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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
 Repeat in a Stream while specified predicate holds
```
 {
 @code
 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 ListT<T>
 
 Specified by:
 
 cycleWhile in interface TransformerSeq<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - cycleUntil
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 cycleUntil in interface TransformerSeq<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Parameters:
 
 predicate - repeat while true
 
 Returns:
 
 Repeating Stream
 - zip
```
public <U,R> ListTSeq<R> zip(java.lang.Iterable<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zip in interface ListT<T>
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 - zipStream
```
public  ListTSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zipStream(java.util.stream.Stream<? extends U> other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zipStream in interface ListT<T>
 
 Specified by:
 
 zipStream in interface TransformerSeq<T>
 
 Specified by:
 
 zipStream in interface Traversable<T>
 - zip
```
public  ListTSeq<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)
```
 Description copied from interface: Traversable
 Zip 2 streams into one
```
 {
 @code
 List<Tuple2<Integer, String>> list = of(1, 2).zip(of("a", "b", "c", "d")).toList();
 // [[1,"a"],[2,"b"]]
 }
 
```
 Specified by:
 
 zip in interface ListT<T>
 
 Specified by:
 
 zip in interface TransformerSeq<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 - zip3
```
public <S,U> ListTSeq<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
```
 {
 @code
 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 ListT<T>
 
 Specified by:
 
 zip3 in interface TransformerSeq<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 - zip4
```
public <T2,T3,T4> ListTSeq<org.jooq.lambda.tuple.Tuple4<T,T2,T3,T4>> zip4(java.util.stream.Stream<T2> second,
 java.util.stream.Stream<T3> third,
 java.util.stream.Stream<T4> fourth)
```
 Description copied from interface: Traversable
 zip 4 Streams into 1
```
 {
 @code
 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 ListT<T>
 
 Specified by:
 
 zip4 in interface TransformerSeq<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 - zipWithIndex
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 zipWithIndex in interface TransformerSeq<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 - sliding
```
public ListTSeq<ListX<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 {
 @code
 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 ListT<T>
 
 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
```
public ListTSeq<ListX<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 Create a sliding view over this Sequence
```
 {
 @code
 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 ListT<T>
 
 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
```
public <C extends java.util.Collection<? super T>> ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
 - groupedStatefullyWhile
```
public ListTSeq<ListX<T>> groupedStatefullyWhile(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)
 .groupedStatefullyWhile((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedStatefullyWhile in interface ListT<T>
 
 Specified by:
 
 groupedStatefullyWhile in interface TransformerSeq<T>
 
 Specified by:
 
 groupedStatefullyWhile in interface Traversable<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - groupedWhile
```
public ListTSeq<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 ListT<T>
 
 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
```
public <C extends java.util.Collection<? super T>> ListTSeq<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 ListT<T>
 
 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
```
public <C extends java.util.Collection<? super T>> ListTSeq<C> groupedUntil(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 until the predicate holds
```
 
 assertThat(ReactiveSeq.of(1,2,3,4,5,6)
 .batchUntil(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedUntil in interface ListT<T>
 
 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
```
public ListTSeq<ListX<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 {
 @code
 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 ListT<T>
 
 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
```
public <K,A,D> ListTSeq<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> downstream)
```
 Specified by:
 
 grouped in interface ListT<T>
 
 Specified by:
 
 grouped in interface TransformerSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 - grouped
```
public <K> ListTSeq<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 ListT<T>
 
 Specified by:
 
 grouped in interface TransformerSeq<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 - distinct
```
public ListTSeq<T> distinct()
```
 Specified by:
 
 distinct in interface ListT<T>
 
 Specified by:
 
 distinct in interface TransformerSeq<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 - scanLeft
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 scanLeft in interface TransformerSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Returns:
 - scanLeft
```
public  ListTSeq 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 ListT<T>
 
 Specified by:
 
 scanLeft in interface TransformerSeq<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 - scanRight
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 scanRight in interface TransformerSeq<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - scanRight
```
public  ListTSeq 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 ListT<T>
 
 Specified by:
 
 scanRight in interface TransformerSeq<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 - sorted
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 sorted in interface TransformerSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 - sorted
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 sorted in interface TransformerSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeWhile
```
public ListTSeq<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeWhile in interface ListT<T>
 
 Specified by:
 
 takeWhile in interface TransformerSeq<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 - dropWhile
```
public ListTSeq<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropWhile in interface ListT<T>
 
 Specified by:
 
 dropWhile in interface TransformerSeq<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 - takeUntil
```
public ListTSeq<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 takeUntil in interface ListT<T>
 
 Specified by:
 
 takeUntil in interface TransformerSeq<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 - dropUntil
```
public ListTSeq<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Specified by:
 
 dropUntil in interface ListT<T>
 
 Specified by:
 
 dropUntil in interface TransformerSeq<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 - dropRight
```
public ListTSeq<T> dropRight(int num)
```
 Specified by:
 
 dropRight in interface ListT<T>
 
 Specified by:
 
 dropRight in interface TransformerSeq<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 - takeRight
```
public ListTSeq<T> takeRight(int num)
```
 Specified by:
 
 takeRight in interface ListT<T>
 
 Specified by:
 
 takeRight in interface TransformerSeq<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 - skip
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 intersperse in interface TransformerSeq<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 - reverse
```
public ListTSeq<T> reverse()
```
 Specified by:
 
 reverse in interface ListT<T>
 
 Specified by:
 
 reverse in interface TransformerSeq<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 - shuffle
```
public ListTSeq<T> shuffle()
```
 Specified by:
 
 shuffle in interface ListT<T>
 
 Specified by:
 
 shuffle in interface TransformerSeq<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - skipLast
```
public ListTSeq<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 ListT<T>
 
 Specified by:
 
 skipLast in interface TransformerSeq<T>
 
 Specified by:
 
 skipLast in interface Traversable<T>
 
 Returns:
 - limitLast
```
public ListTSeq<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 ListT<T>
 
 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
```
public ListTSeq<T> onEmpty(T value)
```
 Specified by:
 
 onEmpty in interface ListT<T>
 
 Specified by:
 
 onEmpty in interface TransformerSeq<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 - onEmptyGet
```
public ListTSeq<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Specified by:
 
 onEmptyGet in interface ListT<T>
 
 Specified by:
 
 onEmptyGet in interface TransformerSeq<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 - onEmptyThrow
```
public <X extends java.lang.Throwable> ListTSeq<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)
```
 Specified by:
 
 onEmptyThrow in interface ListT<T>
 
 Specified by:
 
 onEmptyThrow in interface TransformerSeq<T>
 
 Specified by:
 
 onEmptyThrow in interface Traversable<T>
 - shuffle
```
public ListTSeq<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface ListT<T>
 
 Specified by:
 
 shuffle in interface TransformerSeq<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 - slice
```
public ListTSeq<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface ListT<T>
 
 Specified by:
 
 slice in interface TransformerSeq<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 - sorted
```
public > ListTSeq<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface ListT<T>
 
 Specified by:
 
 sorted in interface TransformerSeq<T>
 
 Specified by:
 
 sorted in interface Traversable<T>

Class ListTSeq<T>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.aol.cyclops.control.monads.transformers.ListT

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.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

unwrap

peek

filter

map

flatMap

flatMapT

lift

lift2

fromAnyM

of

of

fromStream

toString

unit

stream

iterator

unitIterator

empty

nestedFoldables

nestedCollectables

unitAnyM

transformerStream

emptyList

isSeqPresent

combine

cycle

cycle

cycleWhile

cycleUntil

zip

zipStream

zip

zip3

zip4

zipWithIndex

sliding

sliding

grouped

groupedUntil

groupedStatefullyWhile

groupedWhile

groupedWhile

groupedUntil

grouped

grouped

grouped

distinct

scanLeft

scanLeft

scanRight

scanRight

sorted

sorted

takeWhile

dropWhile

takeUntil

dropUntil

dropRight

takeRight

skip

skipWhile

skipUntil

limit

limitWhile

limitUntil

intersperse

reverse

shuffle