ListT (simple-react 1.0.0-RC4 API)

Type Parameters:

T -

All Superinterfaces:

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

All Known Implementing Classes:

ListTSeq, ListTValue
```
public interface ListT<T>
extends FoldableTransformerSeq<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 Abstract Methods Default Methods
Modifier and Type	Method and Description
`default <B> ListT<B>`	`bind(java.util.function.Function<? super T,ListT<B>> f)` Flat Map the wrapped List
`default <U> ListT<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default ListT<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.
`default ListT<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default ListT<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default ListT<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default ListT<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default ListT<T>`	`distinct()`
`default ListT<T>`	`dropRight(int num)`
`default ListT<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default ListT<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`<R> ListT<R>`	`empty()`
`static <T> ListTSeq<T>`	`emptyList()`
`static <T> ListTValue<T>`	`emptyOptional()`
`ListT<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped List
`default ListT<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> ListT<B>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)`
`static <A> ListT<A>`	`fromAnyM(AnyM<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>`	`fromAnyMSeq(AnyMSeq<A> anyM)`
`static <A> ListTValue<A>`	`fromAnyMValue(AnyMValue<A> anyM)`
`static <A> ListTValue<A>`	`fromFuture(java.util.concurrent.CompletableFuture<? extends java.util.List<A>> future)`
`static <A> ListTSeq<A>`	`fromIterable(java.lang.Iterable<? extends java.util.List<A>> iterableOfLists)`
`static <A> ListTValue<A>`	`fromOptional(java.util.Optional<? extends java.util.List<A>> optional)`
`static <A> ListTSeq<A>`	`fromPublisher(org.reactivestreams.Publisher<java.util.List<A>> publisherOfLists)`
`static <A> ListTSeq<A>`	`fromStream(java.util.stream.Stream<? extends java.util.List<A>> streamOfLists)`
`static <A> ListT<A>`	`fromStreamAnyM(AnyM<java.util.stream.Stream<A>> monads)` Create a ListT from an AnyM that wraps a monad containing a Stream
`static <A,V extends MonadicValue<? extends java.util.List<A>>> ListTValue<A>`	`fromValue(V monadicValue)`
`default <K> ListT<org.jooq.lambda.tuple.Tuple2<K,org.jooq.lambda.Seq<T>>>`	`grouped(java.util.function.Function<? super T,? extends K> classifier)`
`default <K,A,D> ListT<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)`
`default ListT<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> ListT<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 ListT<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.
`default ListT<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>> ListT<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
`default ListT<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>> ListT<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 ListT<T>`	`intersperse(T value)` Returns a stream with a given value interspersed between any two values of this stream.
`default boolean`	`isSeqPresent()`
`static <U,R> java.util.function.Function<ListT<U>,ListT<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<ListT<U1>,ListT<U2>,ListT<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.
`default ListT<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default ListT<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default ListT<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 ListT<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> ListT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped List
`default ListT<T>`	`notNull()` Filter elements retaining only values which are not null
`static <A> ListT<A>`	`of(AnyM<java.util.List<A>> monads)` Construct an ListT from an AnyM that wraps a monad containing Lists
`default <U> ListT<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default ListT<T>`	`onEmpty(T value)`
`default ListT<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`default <X extends java.lang.Throwable> ListT<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`default <R> ListT<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
`ListT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the List
`default ListT<T>`	`reverse()`
`default ListT<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> ListT<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default ListT<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> ListT<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default ListT<T>`	`shuffle()`
`default ListT<T>`	`shuffle(java.util.Random random)`
`default ListT<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default ListT<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default ListT<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 ListT<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 ListT<T>`	`slice(long from, long to)`
`default ListT<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default ListT<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default ListT<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default ListT<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>> ListT<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default ListT<T>`	`takeRight(int num)`
`default ListT<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default ListT<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default <R> ListT<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> ListT<R>`	`unit(R t)`
`<R> ListT<R>`	`unitIterator(java.util.Iterator<R> it)`
`AnyM<ListX<T>>`	`unwrap()`
`default <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <U,R> ListT<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)`
`default <U,R> ListT<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`default <U,R> ListT<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <S,U> ListT<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> ListT<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 ListT<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, lazyOperations, subscribe, transformerStream, unitAnyM

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

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

Methods inherited from interface com.aol.cyclops.types.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> ListT<R> unitIterator(java.util.Iterator<R> it)

unit
```
<R> ListT<R> unit(R t)
```

empty
```
<R> ListT<R> empty()
```

unwrap
```
AnyM<ListX<T>> unwrap()
```
Returns:

The wrapped AnyM

peek

ListT<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 Functor<T>
Parameters:: peek - Consumer to accept current value of List
Returns:: ListT with peek call

filter
```
ListT<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 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
```
 ListT 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 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

<B> ListT<B> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)

bind

default <B> ListT<B> bind(java.util.function.Function<? super T,ListT<B>> 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

static <U,R> java.util.function.Function<ListT<U>,ListT<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);

Parameters:: fn - Function to enhance with functionality from List and another monad type
Returns:: Function that accepts and returns an ListT

lift2

static <U1,U2,R> java.util.function.BiFunction<ListT<U1>,ListT<U2>,ListT<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);

Parameters:: fn - BiFunction to enhance with functionality from List and another monad type
Returns:: Function that accepts and returns an ListT

fromAnyM
```
static <A> ListT<A> fromAnyM(AnyM<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
```
static <A> ListT<A> of(AnyM<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

fromStreamAnyM
```
static <A> ListT<A> fromStreamAnyM(AnyM<java.util.stream.Stream<A>> monads)
```
Create a ListT from an AnyM that wraps a monad containing a Stream

Parameters:

monads -

Returns:

fromAnyMValue

static <A> ListTValue<A> fromAnyMValue(AnyMValue<A> anyM)

fromAnyMSeq

static <A> ListTSeq<A> fromAnyMSeq(AnyMSeq<A> anyM)

fromIterable

static <A> ListTSeq<A> fromIterable(java.lang.Iterable<? extends java.util.List<A>> iterableOfLists)

fromStream

static <A> ListTSeq<A> fromStream(java.util.stream.Stream<? extends java.util.List<A>> streamOfLists)

fromPublisher

static <A> ListTSeq<A> fromPublisher(org.reactivestreams.Publisher<java.util.List<A>> publisherOfLists)

fromValue

static <A,V extends MonadicValue<? extends java.util.List<A>>> ListTValue<A> fromValue(V monadicValue)

fromOptional

static <A> ListTValue<A> fromOptional(java.util.Optional<? extends java.util.List<A>> optional)

fromFuture

static <A> ListTValue<A> fromFuture(java.util.concurrent.CompletableFuture<? extends java.util.List<A>> future)

emptyOptional

static <T> ListTValue<T> emptyOptional()

emptyList
```
static <T> ListTSeq<T> emptyList()
```

cast
```
default  ListT 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> ListT<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>
Returns:

patternMatch

default <R> ListT<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  ListT 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 ListT<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 ListT<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

isSeqPresent
```
default boolean isSeqPresent()
```
Specified by:

isSeqPresent in interface TransformerSeq<T>

combine
```
default ListT<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 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 ListT<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 ListT<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 ListT<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 TransformerSeq<T>
Specified by:: cycleWhile in interface Traversable<T>
Parameters:: predicate - repeat while true
Returns:: Repeating Stream

cycleUntil

default ListT<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> ListT<R> zip(java.lang.Iterable<? extends U> other,
                           java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface TransformerSeq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U,R> ListT<R> zip(java.util.stream.Stream<? extends U> other,
                           java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface TransformerSeq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U,R> ListT<R> zip(org.jooq.lambda.Seq<? extends U> other,
                           java.util.function.BiFunction<? super T,? super U,? extends R> zipper)

Specified by:: zip in interface TransformerSeq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U> ListT<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

 {
        @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 TransformerSeq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)

Specified by:: zip in interface TransformerSeq<T>
Specified by:: zip in interface Traversable<T>

zip

default <U> ListT<org.jooq.lambda.tuple.Tuple2<T,U>> zip(org.jooq.lambda.Seq<? extends U> other)

Specified by:: zip in interface TransformerSeq<T>
Specified by:: zip in interface Traversable<T>

zip3

default <S,U> ListT<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 TransformerSeq<T>
Specified by:: zip3 in interface Traversable<T>

zip4

default <T2,T3,T4> ListT<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

 {
        @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 TransformerSeq<T>
Specified by:: zip4 in interface Traversable<T>

zipWithIndex

default ListT<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 ListT<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 TransformerSeq<T>
Specified by:: sliding in interface Traversable<T>
Parameters:: windowSize - Size of sliding window
Returns:: SequenceM with sliding view

sliding

default ListT<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 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>> ListT<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 ListT<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

groupedStatefullyWhile
```
default ListT<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 TransformerSeq<T>

Specified by:

groupedStatefullyWhile in interface Traversable<T>

Parameters:

predicate - Window while true

Returns:

Traversable windowed while predicate holds

groupedWhile
```
default ListT<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>> ListT<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>> ListT<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 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 ListT<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 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> ListT<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 TransformerSeq<T>
Specified by:: grouped in interface Traversable<T>

grouped

default <K> ListT<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 TransformerSeq<T>
Specified by:: grouped in interface Traversable<T>

distinct
```
default ListT<T> distinct()
```
Specified by:

distinct in interface TransformerSeq<T>

Specified by:

distinct in interface Traversable<T>

scanLeft

default ListT<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 <U> ListT<U> 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 ListT<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 <U> ListT<U> 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 ListT<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 ListT<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 ListT<T> takeWhile(java.util.function.Predicate<? super T> p)
```
Specified by:

takeWhile in interface TransformerSeq<T>

Specified by:

takeWhile in interface Traversable<T>

dropWhile
```
default ListT<T> dropWhile(java.util.function.Predicate<? super T> p)
```
Specified by:

dropWhile in interface TransformerSeq<T>

Specified by:

dropWhile in interface Traversable<T>

takeUntil
```
default ListT<T> takeUntil(java.util.function.Predicate<? super T> p)
```
Specified by:

takeUntil in interface TransformerSeq<T>

Specified by:

takeUntil in interface Traversable<T>

dropUntil
```
default ListT<T> dropUntil(java.util.function.Predicate<? super T> p)
```
Specified by:

dropUntil in interface TransformerSeq<T>

Specified by:

dropUntil in interface Traversable<T>

dropRight
```
default ListT<T> dropRight(int num)
```
Specified by:

dropRight in interface TransformerSeq<T>

Specified by:

dropRight in interface Traversable<T>

takeRight
```
default ListT<T> takeRight(int num)
```
Specified by:

takeRight in interface TransformerSeq<T>

Specified by:

takeRight in interface Traversable<T>

skip
```
default ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<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 ListT<T> reverse()
```
Specified by:

reverse in interface TransformerSeq<T>

Specified by:

reverse in interface Traversable<T>

shuffle
```
default ListT<T> shuffle()
```
Specified by:

shuffle in interface TransformerSeq<T>

Specified by:

shuffle in interface Traversable<T>

skipLast
```
default ListT<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 ListT<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 ListT<T> onEmpty(T value)
```
Specified by:

onEmpty in interface TransformerSeq<T>

Specified by:

onEmpty in interface Traversable<T>

onEmptyGet
```
default ListT<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
Specified by:

onEmptyGet in interface TransformerSeq<T>

Specified by:

onEmptyGet in interface Traversable<T>

onEmptyThrow

default <X extends java.lang.Throwable> ListT<T> onEmptyThrow(java.util.function.Supplier<? extends X> supplier)

Specified by:: onEmptyThrow in interface TransformerSeq<T>
Specified by:: onEmptyThrow in interface Traversable<T>

shuffle
```
default ListT<T> shuffle(java.util.Random random)
```
Specified by:

shuffle in interface TransformerSeq<T>

Specified by:

shuffle in interface Traversable<T>

slice
```
default ListT<T> slice(long from,
 long to)
```
Specified by:

slice in interface TransformerSeq<T>

Specified by:

slice in interface Traversable<T>

sorted

default <U extends java.lang.Comparable<? super U>> ListT<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 ListT<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.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

unwrap

peek

filter

map

flatMap

bind

lift

lift2

fromAnyM

of

fromStreamAnyM

fromAnyMValue

fromAnyMSeq

fromIterable

fromStream

fromPublisher

fromValue

fromOptional

fromFuture

emptyOptional

emptyList

cast

trampoline

patternMatch

ofType

filterNot

notNull

isSeqPresent

combine

cycle

cycle

cycleWhile

cycleUntil

zip

zip

zip

zip

zip

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