SetT (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:

SetTSeq, SetTValue
```
public interface SetT<T>
extends FoldableTransformerSeq<T>
```
Monad Transformer for Java Sets SetT consists of an AnyM instance that in turns wraps anoter Monad type that contains an Set SetT>>> SetT allows the deeply wrapped Set 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
`static <T> java.util.Set<T>`	`asSet(T... elements)`
`default <B> SetT<B>`	`bind(java.util.function.Function<? super T,SetT<B>> f)` Flat Map the wrapped Set
`default <U> SetT<U>`	`cast(java.lang.Class<? extends U> type)` Cast all elements in a stream to a given type, possibly throwing a `ClassCastException`.
`default SetT<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 SetT<T>`	`cycle(int times)` Convert to a Stream with the values repeated specified times
`default SetT<T>`	`cycle(Monoid<T> m, int times)` Convert to a Stream with the result of a reduction operation repeated specified times
`default SetT<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream until specified predicate holds
`default SetT<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)` Repeat in a Stream while specified predicate holds
`default SetT<T>`	`distinct()`
`default SetT<T>`	`dropRight(int num)`
`default SetT<T>`	`dropUntil(java.util.function.Predicate<? super T> p)`
`default SetT<T>`	`dropWhile(java.util.function.Predicate<? super T> p)`
`<R> SetT<R>`	`empty()`
`static <T> SetTSeq<T>`	`emptySet()`
`SetT<T>`	`filter(java.util.function.Predicate<? super T> test)` Filter the wrapped Set
`default SetT<T>`	`filterNot(java.util.function.Predicate<? super T> fn)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<B> SetT<B>`	`flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends B>> f)`
`static <A> SetT<A>`	`fromAnyM(AnyM<A> anyM)` Construct an SetT from an AnyM that contains a monad type that contains type other than Set The values in the underlying monad will be mapped to Set
`static <A> SetTSeq<A>`	`fromAnyMSeq(AnyMSeq<A> anyM)`
`static <A> SetTValue<A>`	`fromAnyMValue(AnyMValue<A> anyM)`
`static <A> SetTValue<A>`	`fromFuture(java.util.concurrent.CompletableFuture<java.util.Set<A>> future)`
`static <A> SetTSeq<A>`	`fromIterable(java.lang.Iterable<? extends java.util.Set<A>> iterableOfSets)`
`static <A> SetTValue<A>`	`fromIterableValue(java.lang.Iterable<? extends java.util.Set<A>> iterableOfSets)`
`static <A> SetTValue<A>`	`fromOptional(java.util.Optional<? extends java.util.Set<A>> optional)`
`static <A> SetTSeq<A>`	`fromPublisher(org.reactivestreams.Publisher<? extends java.util.Set<A>> publisherOfSets)`
`static <A> SetT<A>`	`fromStream(AnyM<java.util.stream.Stream<A>> monads)` Create a SetT from an AnyM that wraps a monad containing a Stream
`static <A> SetTSeq<A>`	`fromStream(java.util.stream.Stream<? extends java.util.Set<A>> streamOfSets)`
`static <A,V extends MonadicValue<? extends java.util.Set<A>>> SetTValue<A>`	`fromValue(V monadicValue)`
`default <K> SetT<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> SetT<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 SetT<ListX<T>>`	`grouped(int groupSize)` Group elements in a Stream
`default <C extends java.util.Collection<? super T>> SetT<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 SetT<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 SetT<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>> SetT<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 SetT<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>> SetT<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 SetT<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<SetT<U>,SetT<R>>`	`lift(java.util.function.Function<? super U,? extends R> fn)` Lift a function into one that accepts and returns an SetT This allows multiple monad types to add functionality to existing functions and methods e.g.
`static <U1,U2,R> java.util.function.BiFunction<SetT<U1>,SetT<U2>,SetT<R>>`	`lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)` Lift a BiFunction into one that accepts and returns SetTs This allows multiple monad types to add functionality to existing functions and methods e.g.
`default SetT<T>`	`limit(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).limit(2).toList(),equalTo(Arrays.asList(4,3));`
`default SetT<T>`	`limitLast(int num)` Limit results to the last x elements in a SequenceM
`default SetT<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 SetT<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> SetT<B>`	`map(java.util.function.Function<? super T,? extends B> f)` Map the wrapped Set
`default SetT<T>`	`notNull()` Filter elements retaining only values which are not null
`static <A> SetT<A>`	`of(AnyM<java.util.Set<A>> monads)` Construct an SetT from an AnyM that wraps a monad containing Sets
`default <U> SetT<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`default SetT<T>`	`onEmpty(T value)`
`default SetT<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)`
`default <X extends java.lang.Throwable> SetT<T>`	`onEmptyThrow(java.util.function.Supplier<? extends X> supplier)`
`default <R> SetT<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
`SetT<T>`	`peek(java.util.function.Consumer<? super T> peek)` Peek at the current value of the Set
`default SetT<T>`	`reverse()`
`default SetT<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`default <U> SetT<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`default SetT<T>`	`scanRight(Monoid<T> monoid)` Scan right
`default <U> SetT<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`default SetT<T>`	`shuffle()`
`default SetT<T>`	`shuffle(java.util.Random random)`
`default SetT<T>`	`skip(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).skip(2).toList(),equalTo(Arrays.asList(6,7)));`
`default SetT<T>`	`skipLast(int num)` assertThat(ReactiveSeq.of(1,2,3,4,5) .skipLast(2) .collect(Collectors.toList()),equalTo(Arrays.asList(1,2,3)));
`default SetT<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 SetT<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 SetT<T>`	`slice(long from, long to)`
`default SetT<ListX<T>>`	`sliding(int windowSize)` Create a sliding view over this Sequence
`default SetT<ListX<T>>`	`sliding(int windowSize, int increment)` Create a sliding view over this Sequence
`default SetT<T>`	`sorted()` `assertThat(ReactiveSeq.of(4,3,6,7)).sorted().toList(),equalTo(Arrays.asList(3,4,6,7)));`
`default SetT<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>> SetT<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`default SetT<T>`	`takeRight(int num)`
`default SetT<T>`	`takeUntil(java.util.function.Predicate<? super T> p)`
`default SetT<T>`	`takeWhile(java.util.function.Predicate<? super T> p)`
`default <R> SetT<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> SetT<R>`	`unit(R t)`
`<R> SetT<R>`	`unitIterator(java.util.Iterator<R> it)`
`AnyM<SetX<T>>`	`unwrap()`
`default <U> SetT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`default <U,R> SetT<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> SetT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(org.jooq.lambda.Seq<? extends U> other)`
`default <U,R> SetT<R>`	`zip(org.jooq.lambda.Seq<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <U> SetT<org.jooq.lambda.tuple.Tuple2<T,U>>`	`zip(java.util.stream.Stream<? extends U> other)` Zip 2 streams into one
`default <U,R> SetT<R>`	`zip(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`
`default <S,U> SetT<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> SetT<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 SetT<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
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> SetT<R> unitIterator(java.util.Iterator<R> it)

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

empty
```
<R> SetT<R> empty()
```

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

The wrapped AnyM

flatMap

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

peek

SetT<T> peek(java.util.function.Consumer<? super T> peek)

Peek at the current value of the Set

  
    SetT.of(AnyM.fromStream(Arrays.asSet(10))
             .peek(System.out::println);
             
     //prints 10

Specified by:: peek in interface Functor<T>
Parameters:: peek - Consumer to accept current value of Set
Returns:: SetT with peek call

filter
```
SetT<T> filter(java.util.function.Predicate<? super T> test)
```
Filter the wrapped Set
```
 
 SetT.of(AnyM.fromStream(Arrays.asSet(10,11))
 .filter(t->t!=10);
 
 //SetT<AnyM<Stream<Set[11]>>>
 
 
```
Specified by:

filter in interface Filterable<T>

Specified by:

filter in interface FilterableFunctor<T>

Parameters:

test - Predicate to filter the wrapped Set

Returns:

SetT that applies the provided filter

map
```
 SetT map(java.util.function.Function<? super T,? extends B> f)
```
Map the wrapped Set
```
 
 SetT.of(AnyM.fromStream(Arrays.asSet(10))
 .map(t->t=t+1);
 
 
 //SetT<AnyM<Stream<Set[11]>>>
 
 
```
Specified by:

map in interface FilterableFunctor<T>

Specified by:

map in interface Functor<T>

Parameters:

f - Mapping function for the wrapped Set

Returns:

SetT that applies the map function to the wrapped Set

bind

default <B> SetT<B> bind(java.util.function.Function<? super T,SetT<B>> f)

Flat Map the wrapped Set

  
  SetT.of(AnyM.fromStream(Arrays.asSet(10))
             .flatMap(t->Set.empty();
  
  
  //SetT<AnyM<Stream<Set.empty>>>

Parameters:: f - FlatMap function
Returns:: SetT that applies the flatMap function to the wrapped Set

lift

static <U,R> java.util.function.Function<SetT<U>,SetT<R>> lift(java.util.function.Function<? super U,? extends R> fn)

Lift a function into one that accepts and returns an SetT This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling (via Set) and iteration (via Stream) to an existing function

  
 Function<Integer,Integer> add2 = i -> i+2;
		Function<SetT<Integer>, SetT<Integer>> optTAdd2 = SetT.lift(add2);
		
		Stream<Integer> nums = Stream.of(1,2);
		AnyM<Stream<Integer>> stream = AnyM.ofMonad(asSet(nums));
		
		Set<Integer> results = optTAdd2.apply(SetT.fromStream(stream))
										.unwrap()
										.<Optional<Set<Integer>>>unwrap().get();
		
		
		//asSet(3,4);

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

lift2

static <U1,U2,R> java.util.function.BiFunction<SetT<U1>,SetT<U2>,SetT<R>> lift2(java.util.function.BiFunction<? super U1,? super U2,? extends R> fn)

Lift a BiFunction into one that accepts and returns SetTs This allows multiple monad types to add functionality to existing functions and methods e.g. to add list handling (via Set), iteration (via Stream) and asynchronous execution (CompletableFuture) to an existing function

  
BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;
		BiFunction<SetT<Integer>,SetT<Integer>, SetT<Integer>> optTAdd2 = SetT.lift2(add);
		
		Streamable<Integer> threeValues = Streamable.of(1,2,3);
		AnyM<Integer> stream = AnyM.fromStreamable(threeValues);
		AnyM<Set<Integer>> streamOpt = stream.map(this::asSet);
		
		CompletableFuture<Set<Integer>> two = CompletableFuture.completedFuture(asSet(2));
		AnyM<Set<Integer>> future=  AnyM.fromCompletableFuture(two);
		Set<Integer> results = optTAdd2.apply(SetT.of(streamOpt),SetT.of(future))
										.unwrap()
										.<Stream<Set<Integer>>>unwrap()
										.flatMap(i->i.stream())
										.collect(Collectors.toSet());
			//asSet(3,4);

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

fromAnyM
```
static <A> SetT<A> fromAnyM(AnyM<A> anyM)
```
Construct an SetT from an AnyM that contains a monad type that contains type other than Set The values in the underlying monad will be mapped to Set

Parameters:

anyM - AnyM that doesn't contain a monad wrapping an Set

Returns:

SetT

asSet

static <T> java.util.Set<T> asSet(T... elements)

of
```
static <A> SetT<A> of(AnyM<java.util.Set<A>> monads)
```
Construct an SetT from an AnyM that wraps a monad containing Sets

Parameters:

monads - AnyM that contains a monad wrapping an Set

Returns:

SetT

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

Parameters:

monads -

Returns:

fromAnyMValue

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

fromAnyMSeq

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

fromIterable

static <A> SetTSeq<A> fromIterable(java.lang.Iterable<? extends java.util.Set<A>> iterableOfSets)

fromStream

static <A> SetTSeq<A> fromStream(java.util.stream.Stream<? extends java.util.Set<A>> streamOfSets)

fromPublisher

static <A> SetTSeq<A> fromPublisher(org.reactivestreams.Publisher<? extends java.util.Set<A>> publisherOfSets)

fromValue

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

fromOptional

static <A> SetTValue<A> fromOptional(java.util.Optional<? extends java.util.Set<A>> optional)

fromFuture

static <A> SetTValue<A> fromFuture(java.util.concurrent.CompletableFuture<java.util.Set<A>> future)

fromIterableValue

static <A> SetTValue<A> fromIterableValue(java.lang.Iterable<? extends java.util.Set<A>> iterableOfSets)

emptySet
```
static <T> SetTSeq<T> emptySet()
```

cast
```
default  SetT 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> SetT<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> SetT<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  SetT 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 SetT<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 SetT<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 SetT<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 SetT<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 SetT<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 SetT<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 SetT<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> SetT<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> SetT<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> SetT<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> SetT<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> SetT<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> SetT<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> SetT<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> SetT<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 SetT<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 SetT<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 SetT<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>> SetT<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 SetT<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 SetT<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 SetT<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>> SetT<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>> SetT<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 SetT<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> SetT<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> SetT<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 SetT<T> distinct()
```
Specified by:

distinct in interface TransformerSeq<T>

Specified by:

distinct in interface Traversable<T>

scanLeft

default SetT<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> SetT<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 SetT<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> SetT<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 SetT<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 SetT<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 SetT<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 SetT<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 SetT<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 SetT<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 SetT<T> dropRight(int num)
```
Specified by:

dropRight in interface TransformerSeq<T>

Specified by:

dropRight in interface Traversable<T>

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

takeRight in interface TransformerSeq<T>

Specified by:

takeRight in interface Traversable<T>

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

reverse in interface TransformerSeq<T>

Specified by:

reverse in interface Traversable<T>

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

shuffle in interface TransformerSeq<T>

Specified by:

shuffle in interface Traversable<T>

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

onEmpty in interface TransformerSeq<T>

Specified by:

onEmpty in interface Traversable<T>

onEmptyGet
```
default SetT<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> SetT<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 SetT<T> shuffle(java.util.Random random)
```
Specified by:

shuffle in interface TransformerSeq<T>

Specified by:

shuffle in interface Traversable<T>

slice
```
default SetT<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>> SetT<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 SetT<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

flatMap

peek

filter

map

bind

lift

lift2

fromAnyM

asSet

of

fromStream

fromAnyMValue

fromAnyMSeq

fromIterable

fromStream

fromPublisher

fromValue

fromOptional

fromFuture

fromIterableValue

emptySet

cast

trampoline

patternMatch

ofType

filterNot

notNull

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