HashSet (cyclops 10.3.2 API)

java.lang.Object
- cyclops.data.HashSet<T>

All Implemented Interfaces:

Convert<Higher<DataWitness.hashSet,T>>, Higher<DataWitness.hashSet,T>, Filters<T>, Contains<T>, Folds<T>, FilterableTransformable<T>, Transformable<T>, PersistentCollection<T>, PersistentSet<T>, ReactiveStreamsTerminalOperations<T>, OnEmpty<T>, OnEmptyError<T,ImmutableSet<T>>, OnEmptySwitch<ImmutableSet<T>,ImmutableSet<T>>, IterableFilterable<T>, IterableX<T>, Traversable<T>, Zippable<T>, ImmutableSet<T>, io.kindedj.Hk<DataWitness.hashSet,T>, java.io.Serializable, java.lang.Iterable<T>, org.reactivestreams.Publisher<T>
```
public final class HashSet<T>
extends java.lang.Object
implements ImmutableSet<T>, Higher<DataWitness.hashSet,T>, java.io.Serializable
```
See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

HashSet()

Constructors
Constructor and Description
`HashSet()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`HashSet<T>`	`add(T value)`
`HashSet<T>`	`append(T append)`
`HashSet<T>`	`appendAll(java.lang.Iterable<? extends T> it)`
`HashSet<T>`	`appendAll(T... values)`
`HashSet<ReactiveSeq<T>>`	`combinations()`
`HashSet<ReactiveSeq<T>>`	`combinations(int size)`
`HashSet<T>`	`combine(java.util.function.BiPredicate<? super T,? super T> predicate, java.util.function.BinaryOperator<T> op)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`HashSet<T>`	`combine(Monoid<T> op, java.util.function.BiPredicate<? super T,? super T> predicate)` Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation.
`<R> HashSet<R>`	`concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` Perform a flatMap operation on this IterableX.
`boolean`	`containsValue(T value)`
`HashSet<T>`	`cycle(long times)`
`HashSet<T>`	`cycle(Monoid<T> m, long times)`
`HashSet<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)`
`HashSet<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)`
`HashSet<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes
`HashSet<T>`	`distinct()`
`HashSet<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`HashSet<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`HashSet<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`HashSet<T>`	`dropWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
`Tuple2<HashSet<T>,HashSet<T>>`	`duplicate()`
`static <T> HashSet<T>`	`empty()`
`boolean`	`equals(java.lang.Object o)`
`HashSet<T>`	`filter(java.util.function.Predicate<? super T> predicate)` Keep only elements for which the supplied predicates hold e.g.
`HashSet<T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`<R> HashSet<R>`	`flatMap(java.util.function.Function<? super T,? extends ImmutableSet<? extends R>> fn)`
`<R> R`	`foldLeft(R zero, java.util.function.BiFunction<R,? super T,R> f)`
`<R1,R> HashSet<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R> HashSet<R>`	`forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction, java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)`
`<R1,R2,R> HashSet<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<R1,R2,R> HashSet<R>`	`forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction, Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)`
`<R1,R2,R3,R> HashSet<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`<R1,R2,R3,R> HashSet<R>`	`forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1, java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2, Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3, Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction, Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)`
`static <T> HashSet<T>`	`fromIterable(java.lang.Iterable<T> it)`
`static <T> HashSet<T>`	`fromIterator(java.util.Iterator<T> it)`
`static <T> HashSet<T>`	`fromStream(java.util.stream.Stream<T> stream)`
`static <T> HashSet<T>`	`generate(Generator<T> s)` Deprecated.
`static <T> HashSet<T>`	`generate(java.util.function.Supplier<T> s, int max)`
`HashSet<Vector<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends PersistentCollection<? super T>> HashSet<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Group the elements of this traversable
`HashSet<Vector<T>>`	`groupedUntil(java.util.function.BiPredicate<Vector<? super T>,? super T> predicate)` Create Travesable of Lists where each List is populated while the supplied bipredicate holds.
`HashSet<Vector<T>>`	`groupedUntil(java.util.function.Predicate<? super T> predicate)` `ReactiveSeq.of(1,2,3,4,5,6) .groupedUntil(i->i%3==0) .toList() .size(); //2`
`<C extends PersistentCollection<? super T>> HashSet<C>`	`groupedUntil(java.util.function.Predicate<? super T> predicate, java.util.function.Supplier<C> factory)` Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
`HashSet<Vector<T>>`	`groupedWhile(java.util.function.Predicate<? super T> predicate)` Create a Traversable batched by List, where each batch is populated while the predicate holds
`<C extends PersistentCollection<? super T>> HashSet<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
`int`	`hashCode()`
`HashSet<T>`	`insertAt(int pos, java.lang.Iterable<? extends T> values)`
`HashSet<T>`	`insertAt(int pos, T... values)` Insert data into a traversable at given position
`HashSet<T>`	`insertAt(int i, T value)`
`HashSet<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this traversable at the specified position
`HashSet<T>`	`intersperse(T value)` Returns a Traversable with a given value interspersed between any two values.
`boolean`	`isEmpty()`
`static <T> HashSet<T>`	`iterate(T seed, java.util.function.Predicate<? super T> pred, java.util.function.UnaryOperator<T> f)`
`static <T> HashSet<T>`	`iterate(T seed, java.util.function.UnaryOperator<T> f, int max)`
`java.util.Iterator<T>`	`iterator()`
`<R> HashSet<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> HashSet<R>`	`mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> HashSet<R>`	`mergeMap(int maxConcurecy, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`java.lang.String`	`mkString()`
`HashSet<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> HashSet<T>`	`of(T... values)`
`<U> HashSet<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`HashSet<T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`HashSet<T>`	`onEmptyGet(java.util.function.Supplier<? extends T> supplier)` If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
`HashSet<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`HashSet<ReactiveSeq<T>>`	`permutations()`
`HashSet<T>`	`plus(T value)`
`HashSet<T>`	`plusAll(java.lang.Iterable<? extends T> list)`
`HashSet<T>`	`prepend(T value)`
`HashSet<T>`	`prependAll(java.lang.Iterable<? extends T> value)`
`HashSet<T>`	`prependAll(T... values)` `List<String> result = ReactiveSeq.of(1,2,3) .prependAll(100,200,300) .map(it ->it+"!!") .collect(CyclopsCollectors.toList()); //asList("100!!","200!!","300!!","1!!","2!!","3!!")));`
`HashSet<T>`	`prependStream(java.util.stream.Stream<? extends T> stream)`
`static HashSet<java.lang.Integer>`	`range(int start, int end)`
`static HashSet<java.lang.Integer>`	`range(int start, int step, int end)`
`static HashSet<java.lang.Long>`	`rangeLong(long start, long end)`
`static HashSet<java.lang.Long>`	`rangeLong(long start, long step, long end)`
`HashSet<T>`	`removeAll(java.lang.Iterable<? extends T> list)` Remove all elements in the supplied Iterable from this filterable
`HashSet<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`HashSet<T>`	`removeAt(long pos)`
`HashSet<T>`	`removeFirst(java.util.function.Predicate<? super T> pred)`
`HashSet<T>`	`removeStream(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`HashSet<T>`	`removeValue(T value)`
`HashSet<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`HashSet<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`HashSet<T>`	`retainStream(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filters
`HashSet<T>`	`reverse()`
`HashSet<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> HashSet<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`HashSet<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> HashSet<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`HashSet<T>`	`shuffle()`
`HashSet<T>`	`shuffle(java.util.Random random)`
`static <T> HashSet<T>`	`singleton(T value)`
`int`	`size()`
`HashSet<T>`	`slice(long from, long to)`
`HashSet<Seq<T>>`	`sliding(int windowSize)` Create a sliding view
`HashSet<Seq<T>>`	`sliding(int windowSize, int increment)` Create a sliding view
`HashSet<T>`	`sorted()` {@code ReactiveSeq.of(4,3,6,7)) .sorted() .toList() //Arrays.asList(3,4,6,7)
`HashSet<T>`	`sorted(java.util.Comparator<? super T> c)` `assertThat(ReactiveSeq.of(4,3,6,7).sorted((a,b) -> b-a).toList(),equalTo(Arrays.asList(7,6,4,3)));`
`<U extends java.lang.Comparable<? super U>> HashSet<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`ReactiveSeq<T>`	`stream()`
`HashSet<T>`	`take(long n)` {@code ReactiveSeq.of(4,3,6,7) .take(2) .toList() asList(4,3)
`HashSet<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`HashSet<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`HashSet<T>`	`takeWhile(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
`java.lang.String`	`toString()`
`static <U,T> HashSet<T>`	`unfold(U seed, java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder)`
`<R> HashSet<R>`	`unitIterable(java.lang.Iterable<R> it)`
`<R> HashSet<R>`	`unitStream(java.util.stream.Stream<R> stream)`
`<R1,R2> Tuple2<HashSet<R1>,HashSet<R2>>`	`unzip(java.util.function.Function<? super T,Tuple2<? extends R1,? extends R2>> fn)`
`static <T,U> Tuple2<HashSet<T>,HashSet<U>>`	`unzip(HashSet<Tuple2<T,U>> sequence)`
`HashSet<T>`	`updateAt(int pos, T value)`
`<T2,R> HashSet<R>`	`zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn, org.reactivestreams.Publisher<? extends T2> publisher)` Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
`<U> HashSet<Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`<U,R> HashSet<R>`	`zip(java.lang.Iterable<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)` Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
`<S,U> HashSet<Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)`
`<S,U,R> HashSet<R>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third, Function3<? super T,? super S,? super U,? extends R> fn3)`
`<T2,T3,T4> HashSet<Tuple4<T,T2,T3,T4>>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth)`
`<T2,T3,T4,R> HashSet<R>`	`zip4(java.lang.Iterable<? extends T2> second, java.lang.Iterable<? extends T3> third, java.lang.Iterable<? extends T4> fourth, Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)`
`HashSet<Tuple2<T,java.lang.Long>>`	`zipWithIndex()`
`<U> HashSet<Tuple2<T,U>>`	`zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)`
`<U> HashSet<Tuple2<T,U>>`	`zipWithStream(java.util.stream.Stream<? extends U> other)`
`<U,R> HashSet<R>`	`zipWithStream(java.util.stream.Stream<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> zipper)`

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

Methods inherited from interface cyclops.data.ImmutableSet
onEmptySwitch, onEmptyTry, traversable

Methods inherited from interface com.oath.cyclops.types.persistent.PersistentSet
setView

Methods inherited from interface com.oath.cyclops.types.foldable.Contains
contains

Methods inherited from interface com.oath.cyclops.types.traversable.IterableX
asFunction, equalToIteration, foldFuture, foldLazy, foldTry, forEach, forEach, forEach, forEach, forEach, forEachSubscribe, forEachSubscribe, forEachSubscribe, runFuture, runLazy, seq, to, toHashSet

Methods inherited from interface com.oath.cyclops.types.traversable.Traversable
fixedDelay, insertAt, onePer, subscribe, xPer

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

Methods inherited from interface com.oath.cyclops.types.foldable.Folds
allMatch, anyMatch, atPercentile, bankersQueue, collect, collect, collect, collect, count, countDistinct, doubleStats, elementAt, endsWith, firstValue, foldLeft, foldLeft, foldLeft, foldLeft, foldLeft, foldMap, foldMap, foldMapRight, foldRight, foldRight, foldRight, groupBy, hashSet, headOption, indexOf, indexOfSlice, intStats, iterableTo, join, join, join, lastIndexOf, lastIndexOfSlice, lazySeq, longStats, maxBy, maxBy, maximum, mean, median, minBy, minBy, minimum, mode, noneMatch, nonEmptyList, occurances, populationVariance, print, print, printErr, printOut, scheduleStream, single, single, singleOrElse, startsWith, stdDeviation, sumDouble, sumInt, sumLong, takeOne, toArray, toArray, toCollection, toHashMap, toHashMap, toList, toMap, toMap, toSet, treeSet, variance, vector, withPercentiles, xMatch

Methods inherited from interface com.oath.cyclops.hkt.Higher
applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.oath.cyclops.hkt.Convert
convert

- Constructor Detail
 - HashSet
```
public HashSet()
```
- Method Detail
 - empty
```
public static <T> HashSet<T> empty()
```
 - singleton
```
public static <T> HashSet<T> singleton(T value)
```
 - of
```
public static <T> HashSet<T> of(T... values)
```
 - unfold
```
public static <U,T> HashSet<T> unfold(U seed,
 java.util.function.Function<? super U,Option<Tuple2<T,U>>> unfolder)
```
 - iterate
```
public static <T> HashSet<T> iterate(T seed,
 java.util.function.Predicate<? super T> pred,
 java.util.function.UnaryOperator<T> f)
```
 - iterate
```
public static <T> HashSet<T> iterate(T seed,
 java.util.function.UnaryOperator<T> f,
 int max)
```
 - unzip
```
public static <T,U> Tuple2<HashSet<T>,HashSet> unzip(HashSet<Tuple2<T,U>> sequence)
```
 - generate
```
public static <T> HashSet<T> generate(java.util.function.Supplier<T> s,
 int max)
```
 - generate
```
@Deprecated
public static <T> HashSet<T> generate(Generator<T> s)
```
 Deprecated.
 - range
```
public static HashSet<java.lang.Integer> range(int start,
 int end)
```
 - range
```
public static HashSet<java.lang.Integer> range(int start,
 int step,
 int end)
```
 - rangeLong
```
public static HashSet<java.lang.Long> rangeLong(long start,
 long step,
 long end)
```
 - rangeLong
```
public static HashSet<java.lang.Long> rangeLong(long start,
 long end)
```
 - fromStream
```
public static <T> HashSet<T> fromStream(java.util.stream.Stream<T> stream)
```
 - fromIterable
```
public static <T> HashSet<T> fromIterable(java.lang.Iterable<T> it)
```
 - fromIterator
```
public static <T> HashSet<T> fromIterator(java.util.Iterator<T> it)
```
 - unitIterable
```
public <R> HashSet<R> unitIterable(java.lang.Iterable<R> it)
```
 Specified by:
 
 unitIterable in interface IterableX<T>
 
 Specified by:
 
 unitIterable in interface Traversable<T>
 
 Specified by:
 
 unitIterable in interface ImmutableSet<T>
 - containsValue
```
public boolean containsValue(T value)
```
 Specified by:
 
 containsValue in interface PersistentCollection<T>
 
 Specified by:
 
 containsValue in interface IterableX<T>
 
 Specified by:
 
 containsValue in interface ImmutableSet<T>
 - size
```
public int size()
```
 Specified by:
 
 size in interface PersistentCollection<T>
 
 Specified by:
 
 size in interface IterableX<T>
 
 Specified by:
 
 size in interface ImmutableSet<T>
 - add
```
public HashSet<T> add(T value)
```
 Specified by:
 
 add in interface ImmutableSet<T>
 - removeValue
```
public HashSet<T> removeValue(T value)
```
 Specified by:
 
 removeValue in interface PersistentCollection<T>
 
 Specified by:
 
 removeValue in interface PersistentSet<T>
 
 Specified by:
 
 removeValue in interface IterableX<T>
 
 Specified by:
 
 removeValue in interface ImmutableSet<T>
 - isEmpty
```
public boolean isEmpty()
```
 Specified by:
 
 isEmpty in interface PersistentCollection<T>
 
 Specified by:
 
 isEmpty in interface IterableX<T>
 
 Specified by:
 
 isEmpty in interface ImmutableSet<T>
 - map
```
public <R> HashSet<R> map(java.util.function.Function<? super T,? extends R> fn)
```
 Description copied from interface: Transformable
 Transform this functor using the supplied transformation function
```
 


 of(1,2,3).map(i->i*2)

 //[2,4,6]

 
 
```
 Specified by:
 
 map in interface FilterableTransformable<T>
 
 Specified by:
 
 map in interface Transformable<T>
 
 Specified by:
 
 map in interface IterableX<T>
 
 Specified by:
 
 map in interface Traversable<T>
 
 Specified by:
 
 map in interface ImmutableSet<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Transformable
 - flatMap
```
public <R> HashSet<R> flatMap(java.util.function.Function<? super T,? extends ImmutableSet<? extends R>> fn)
```
 Specified by:
 
 flatMap in interface ImmutableSet<T>
 - concatMap
```
public <R> HashSet<R> concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)
```
 Description copied from interface: IterableX
 
 Perform a flatMap operation on this IterableX. Results from the returned Iterables (from the provided transformation function) are flattened into the resulting toX.
 
 Specified by:
 
 concatMap in interface IterableX<T>
 
 Specified by:
 
 concatMap in interface ImmutableSet<T>
 
 Parameters:
 
 fn - Transformation function to be applied (and flattened)
 
 Returns:
 
 An IterableX containing the flattened results of the transformation function
 - mergeMap
```
public <R> HashSet<R> mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 mergeMap in interface IterableX<T>
 
 Specified by:
 
 mergeMap in interface ImmutableSet<T>
 - mergeMap
```
public <R> HashSet<R> mergeMap(int maxConcurecy,
 java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)
```
 Specified by:
 
 mergeMap in interface IterableX<T>
 
 Specified by:
 
 mergeMap in interface ImmutableSet<T>
 - forEach4
```
public <R1,R2,R3,R> HashSet<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
 Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach4 in interface ImmutableSet<T>
 - forEach4
```
public <R1,R2,R3,R> HashSet<R> forEach4(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,? extends java.lang.Iterable<R3>> iterable3,
 Function4<? super T,? super R1,? super R2,? super R3,java.lang.Boolean> filterFunction,
 Function4<? super T,? super R1,? super R2,? super R3,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach4 in interface ImmutableSet<T>
 - forEach3
```
public <R1,R2,R> HashSet<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach3 in interface ImmutableSet<T>
 - forEach3
```
public <R1,R2,R> HashSet<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends java.lang.Iterable<R2>> iterable2,
 Function3<? super T,? super R1,? super R2,java.lang.Boolean> filterFunction,
 Function3<? super T,? super R1,? super R2,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach3 in interface ImmutableSet<T>
 - forEach2
```
public <R1,R> HashSet<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach2 in interface ImmutableSet<T>
 - forEach2
```
public <R1,R> HashSet<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> iterable1,
 java.util.function.BiFunction<? super T,? super R1,java.lang.Boolean> filterFunction,
 java.util.function.BiFunction<? super T,? super R1,? extends R> yieldingFunction)
```
 Specified by:
 
 forEach2 in interface ImmutableSet<T>
 - filter
```
public HashSet<T> filter(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Filters
 Keep only elements for which the supplied predicates hold e.g.
```
 

 of(1,2,3).filter(i->i>2);

 //[3]

 
 
```
 Specified by:
 
 filter in interface Filters<T>
 
 Specified by:
 
 filter in interface FilterableTransformable<T>
 
 Specified by:
 
 filter in interface IterableX<T>
 
 Specified by:
 
 filter in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - unitStream
```
public <R> HashSet<R> unitStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 unitStream in interface ImmutableSet<T>
 - plus
```
public HashSet<T> plus(T value)
```
 Specified by:
 
 plus in interface PersistentCollection<T>
 
 Specified by:
 
 plus in interface PersistentSet<T>
 
 Specified by:
 
 plus in interface IterableX<T>
 
 Specified by:
 
 plus in interface ImmutableSet<T>
 - plusAll
```
public HashSet<T> plusAll(java.lang.Iterable<? extends T> list)
```
 Specified by:
 
 plusAll in interface PersistentCollection<T>
 
 Specified by:
 
 plusAll in interface PersistentSet<T>
 
 Specified by:
 
 plusAll in interface IterableX<T>
 
 Specified by:
 
 plusAll in interface ImmutableSet<T>
 - removeAll
```
public HashSet<T> removeAll(java.lang.Iterable<? extends T> list)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Iterable from this filterable
 
 Specified by:
 
 removeAll in interface PersistentCollection<T>
 
 Specified by:
 
 removeAll in interface PersistentSet<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface IterableX<T>
 
 Specified by:
 
 removeAll in interface ImmutableSet<T>
 
 Parameters:
 
 list - an Iterable of elements to removeValue
 
 Returns:
 
 Filters with all supplied elements removed
 - stream
```
public ReactiveSeq<T> stream()
```
 Specified by:
 
 stream in interface Folds<T>
 
 Specified by:
 
 stream in interface PersistentCollection<T>
 
 Specified by:
 
 stream in interface PersistentSet<T>
 
 Specified by:
 
 stream in interface IterableX<T>
 
 Specified by:
 
 stream in interface Traversable<T>
 
 Specified by:
 
 stream in interface ImmutableSet<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - equals
```
public boolean equals(java.lang.Object o)
```
 Overrides:
 
 equals in class java.lang.Object
 - hashCode
```
public int hashCode()
```
 Overrides:
 
 hashCode in class java.lang.Object
 - toString
```
public java.lang.String toString()
```
 Overrides:
 
 toString in class java.lang.Object
 - take
```
public HashSet<T> take(long n)
```
 Description copied from interface: Traversable
```
 {@code
 ReactiveSeq.of(4,3,6,7)
 .take(2)
 .toList()
 asList(4,3)
 
```
 Specified by:
 
 take in interface IterableX<T>
 
 Specified by:
 
 take in interface Traversable<T>
 
 Specified by:
 
 take in interface ImmutableSet<T>
 
 Parameters:
 
 n - Elements to take
 
 Returns:
 
 Traversable with specified number of elements
 - takeWhile
```
public HashSet<T> takeWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable as long as the predicate holds
```
 
 Seq.of(1,2,3).takeWhile(i<3);
 //[1,2]
 
 
```
 Specified by:
 
 takeWhile in interface IterableX<T>
 
 Specified by:
 
 takeWhile in interface Traversable<T>
 
 Specified by:
 
 takeWhile in interface ImmutableSet<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropWhile
```
public HashSet<T> dropWhile(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable as long as the predicate holds
```
 
 Seq.of(1,2,3).dropWhile(i<3);
 //[3]
 
 
```
 Specified by:
 
 dropWhile in interface IterableX<T>
 
 Specified by:
 
 dropWhile in interface Traversable<T>
 
 Specified by:
 
 dropWhile in interface ImmutableSet<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - drop
```
public HashSet<T> drop(long num)
```
 Description copied from interface: Traversable
```
 assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7))); 
 
```
 Specified by:
 
 drop in interface IterableX<T>
 
 Specified by:
 
 drop in interface Traversable<T>
 
 Specified by:
 
 drop in interface ImmutableSet<T>
 
 Parameters:
 
 num - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - reverse
```
public HashSet<T> reverse()
```
 Specified by:
 
 reverse in interface IterableX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 
 Specified by:
 
 reverse in interface ImmutableSet<T>
 - duplicate
```
public Tuple2<HashSet<T>,HashSet<T>> duplicate()
```
 - unzip
```
public <R1,R2> Tuple2<HashSet<R1>,HashSet<R2>> unzip(java.util.function.Function<? super T,Tuple2<? extends R1,? extends R2>> fn)
```
 - removeFirst
```
public HashSet<T> removeFirst(java.util.function.Predicate<? super T> pred)
```
 Specified by:
 
 removeFirst in interface IterableX<T>
 
 Specified by:
 
 removeFirst in interface Traversable<T>
 
 Specified by:
 
 removeFirst in interface ImmutableSet<T>
 - append
```
public HashSet<T> append(T append)
```
 Specified by:
 
 append in interface IterableX<T>
 
 Specified by:
 
 append in interface Traversable<T>
 
 Specified by:
 
 append in interface ImmutableSet<T>
 - appendAll
```
public HashSet<T> appendAll(java.lang.Iterable<? extends T> it)
```
 Specified by:
 
 appendAll in interface IterableX<T>
 
 Specified by:
 
 appendAll in interface Traversable<T>
 
 Specified by:
 
 appendAll in interface ImmutableSet<T>
 - foldLeft
```
public <R> R foldLeft(R zero,
 java.util.function.BiFunction<R,? super T,R> f)
```
 Specified by:
 
 foldLeft in interface Folds<T>
 - ofType
```
public  HashSet ofType(java.lang.Class<? extends U> type)
```
 Description copied from interface: Filters
 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 Filters<T>
 
 Specified by:
 
 ofType in interface IterableX<T>
 
 Specified by:
 
 ofType in interface ImmutableSet<T>
 - filterNot
```
public HashSet<T> filterNot(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Filters
 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 Filters<T>
 
 Specified by:
 
 filterNot in interface IterableX<T>
 
 Specified by:
 
 filterNot in interface Traversable<T>
 
 Specified by:
 
 filterNot in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
public HashSet<T> notNull()
```
 Description copied from interface: Filters
 Filter elements retaining only values which are not null
```
 

 of(1,2,null,4).nonNull();

 //[1,2,4]

 
 
```
 Specified by:
 
 notNull in interface Filters<T>
 
 Specified by:
 
 notNull in interface IterableX<T>
 
 Specified by:
 
 notNull in interface ImmutableSet<T>
 
 Returns:
 
 Filters with nulls removed
 - peek
```
public HashSet<T> peek(java.util.function.Consumer<? super T> c)
```
 Description copied from interface: Transformable
 Peek at the current value of this Transformable, without transforming it
```
 


 of(1,2,3).map(System.out::println)

 1
 2
 3

 
 
```
 Specified by:
 
 peek in interface Transformable<T>
 
 Specified by:
 
 peek in interface IterableX<T>
 
 Specified by:
 
 peek in interface ImmutableSet<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Transformable
 
 Returns:
 
 Transformable that will peek at each value
 - removeStream
```
public HashSet<T> removeStream(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Remove all elements in the supplied Stream from this filterable
 
 Specified by:
 
 removeStream in interface IterableFilterable<T>
 
 Specified by:
 
 removeStream in interface IterableX<T>
 
 Specified by:
 
 removeStream in interface ImmutableSet<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - retainAll
```
public HashSet<T> retainAll(java.lang.Iterable<? extends T> it)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface IterableX<T>
 
 Specified by:
 
 retainAll in interface ImmutableSet<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainStream
```
public HashSet<T> retainStream(java.util.stream.Stream<? extends T> stream)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainStream in interface IterableFilterable<T>
 
 Specified by:
 
 retainStream in interface IterableX<T>
 
 Specified by:
 
 retainStream in interface ImmutableSet<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
public HashSet<T> retainAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Retain only the supplied elements in the returned Filters
 
 Specified by:
 
 retainAll in interface IterableFilterable<T>
 
 Specified by:
 
 retainAll in interface IterableX<T>
 
 Specified by:
 
 retainAll in interface ImmutableSet<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - permutations
```
public HashSet<ReactiveSeq<T>> permutations()
```
 Specified by:
 
 permutations in interface IterableX<T>
 
 Specified by:
 
 permutations in interface ImmutableSet<T>
 - combinations
```
public HashSet<ReactiveSeq<T>> combinations(int size)
```
 Specified by:
 
 combinations in interface IterableX<T>
 
 Specified by:
 
 combinations in interface ImmutableSet<T>
 - combinations
```
public HashSet<ReactiveSeq<T>> combinations()
```
 Specified by:
 
 combinations in interface IterableX<T>
 
 Specified by:
 
 combinations in interface ImmutableSet<T>
 - zip
```
public <T2,R> HashSet<R> zip(java.util.function.BiFunction<? super T,? super T2,? extends R> fn,
 org.reactivestreams.Publisher<? extends T2> publisher)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Publisher, using the supplied combining function
 
 Specified by:
 
 zip in interface IterableX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Specified by:
 
 zip in interface ImmutableSet<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - zipWithStream
```
public <U,R> HashSet<R> zipWithStream(java.util.stream.Stream<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Specified by:
 
 zipWithStream in interface IterableX<T>
 
 Specified by:
 
 zipWithStream in interface Traversable<T>
 
 Specified by:
 
 zipWithStream in interface ImmutableSet<T>
 - zipWithPublisher
```
public  HashSet<Tuple2<T,U>> zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)
```
 Specified by:
 
 zipWithPublisher in interface IterableX<T>
 
 Specified by:
 
 zipWithPublisher in interface Traversable<T>
 
 Specified by:
 
 zipWithPublisher in interface Zippable<T>
 
 Specified by:
 
 zipWithPublisher in interface ImmutableSet<T>
 - zip
```
public  HashSet<Tuple2<T,U>> zip(java.lang.Iterable<? extends U> other)
```
 Specified by:
 
 zip in interface IterableX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Specified by:
 
 zip in interface ImmutableSet<T>
 - zip3
```
public <S,U,R> HashSet<R> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third,
 Function3<? super T,? super S,? super U,? extends R> fn3)
```
 Specified by:
 
 zip3 in interface IterableX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 
 Specified by:
 
 zip3 in interface ImmutableSet<T>
 - zip4
```
public <T2,T3,T4,R> HashSet<R> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth,
 Function4<? super T,? super T2,? super T3,? super T4,? extends R> fn)
```
 Specified by:
 
 zip4 in interface IterableX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 
 Specified by:
 
 zip4 in interface ImmutableSet<T>
 - combine
```
public HashSet<T> combine(java.util.function.BiPredicate<? super T,? super T> predicate,
 java.util.function.BinaryOperator<T> op)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine((a, b)->a.equals(b),SemigroupK.intSum)
 .listX()

 //Seq(3,4)
 
```
 Can be used to implement terminating lazy folds on lazy data types
```
 
 ReactiveSeq.generate(this::process)
 .map(data->data.isSuccess())
 .combine((a,b)-> a ? false : true, (a,b) -> a|b)
 .findFirst(); //terminating reduction on infinite data structure
 


 
```
 Specified by:
 
 combine in interface IterableX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Specified by:
 
 combine in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element
 
 op - BinaryOperator to combine neighbours
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - combine
```
public HashSet<T> combine(Monoid<T> op,
 java.util.function.BiPredicate<? super T,? super T> predicate)
```
 Description copied from interface: Traversable
 Combine two adjacent elements in a traversable using the supplied BinaryOperator This is a stateful grouping and reduction operation. The emitted result of a combination may in turn be combined with it's neighbour
```
 
 ReactiveSeq.of(1,1,2,3)
 .combine(Monoids.intMult,(a, b)->a.equals(b))
 .listX()

 //Seq(1)
 
```
 Simalar to @see Traversable.combine(BiPredicate, BinaryOperator) but differs in that the first comparison is always to the Monoid zero This allows us to terminate with just a single value
 Specified by:
 
 combine in interface IterableX<T>
 
 Specified by:
 
 combine in interface Traversable<T>
 
 Specified by:
 
 combine in interface ImmutableSet<T>
 
 Parameters:
 
 op - Monoid to combine neighbours
 
 predicate - Test to see if two neighbours should be joined. The first parameter to the bi-predicate is the currently accumulated result and the second is the next element
 
 Returns:
 
 Combined / Partially Reduced Traversable
 - cycle
```
public HashSet<T> cycle(long times)
```
 Specified by:
 
 cycle in interface IterableX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Specified by:
 
 cycle in interface ImmutableSet<T>
 - cycle
```
public HashSet<T> cycle(Monoid<T> m,
 long times)
```
 Specified by:
 
 cycle in interface IterableX<T>
 
 Specified by:
 
 cycle in interface Traversable<T>
 
 Specified by:
 
 cycle in interface ImmutableSet<T>
 - cycleWhile
```
public HashSet<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleWhile in interface IterableX<T>
 
 Specified by:
 
 cycleWhile in interface Traversable<T>
 
 Specified by:
 
 cycleWhile in interface ImmutableSet<T>
 - cycleUntil
```
public HashSet<T> cycleUntil(java.util.function.Predicate<? super T> predicate)
```
 Specified by:
 
 cycleUntil in interface IterableX<T>
 
 Specified by:
 
 cycleUntil in interface Traversable<T>
 
 Specified by:
 
 cycleUntil in interface ImmutableSet<T>
 - zip
```
public <U,R> HashSet<R> zip(java.lang.Iterable<? extends U> other,
 java.util.function.BiFunction<? super T,? super U,? extends R> zipper)
```
 Description copied from interface: Zippable
 
 Zip (combine) this Zippable with the supplied Iterable using the supplied combining function
 
 Specified by:
 
 zip in interface IterableX<T>
 
 Specified by:
 
 zip in interface Traversable<T>
 
 Specified by:
 
 zip in interface Zippable<T>
 
 Specified by:
 
 zip in interface ImmutableSet<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zip3
```
public <S,U> HashSet<Tuple3<T,S,U>> zip3(java.lang.Iterable<? extends S> second,
 java.lang.Iterable<? extends U> third)
```
 Specified by:
 
 zip3 in interface IterableX<T>
 
 Specified by:
 
 zip3 in interface Traversable<T>
 
 Specified by:
 
 zip3 in interface Zippable<T>
 
 Specified by:
 
 zip3 in interface ImmutableSet<T>
 - zip4
```
public <T2,T3,T4> HashSet<Tuple4<T,T2,T3,T4>> zip4(java.lang.Iterable<? extends T2> second,
 java.lang.Iterable<? extends T3> third,
 java.lang.Iterable<? extends T4> fourth)
```
 Specified by:
 
 zip4 in interface IterableX<T>
 
 Specified by:
 
 zip4 in interface Traversable<T>
 
 Specified by:
 
 zip4 in interface Zippable<T>
 
 Specified by:
 
 zip4 in interface ImmutableSet<T>
 - zipWithIndex
```
public HashSet<Tuple2<T,java.lang.Long>> zipWithIndex()
```
 Specified by:
 
 zipWithIndex in interface IterableX<T>
 
 Specified by:
 
 zipWithIndex in interface Traversable<T>
 
 Specified by:
 
 zipWithIndex in interface ImmutableSet<T>
 - sliding
```
public HashSet<Seq<T>> sliding(int windowSize)
```
 Description copied from interface: Traversable
 
 Create a sliding view
 
 Specified by:
 
 sliding in interface IterableX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Specified by:
 
 sliding in interface ImmutableSet<T>
 - sliding
```
public HashSet<Seq<T>> sliding(int windowSize,
 int increment)
```
 Description copied from interface: Traversable
 
 Create a sliding view
 
 Specified by:
 
 sliding in interface IterableX<T>
 
 Specified by:
 
 sliding in interface Traversable<T>
 
 Specified by:
 
 sliding in interface ImmutableSet<T>
 - grouped
```
public <C extends PersistentCollection<? super T>> HashSet<C> grouped(int size,
 java.util.function.Supplier<C> supplier)
```
 Description copied from interface: Traversable
 Group the elements of this traversable
```
 
 ReactiveSeq.of(1,1,1,1,1,1)
 .grouped(3,()->new TreeSet<>())
 .toList()
 .getValue(0)
 .size();
 //1

 ReactiveSeq.of(1,2,3,4,5,6)
 .grouped(3,()->new TreeSet<>())
 .toList()
 .getValue(0)
 .size();
 //3

 
 
```
 Specified by:
 
 grouped in interface IterableX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Specified by:
 
 grouped in interface ImmutableSet<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 Traversable grouped by size
 - groupedUntil
```
public HashSet<Vector<T>> groupedUntil(java.util.function.Predicate<? super T> predicate)
```
 Description copied from interface: Traversable
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3==0)
 .toList()
 .size();
 //2
 
 
```
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Specified by:
 
 groupedUntil in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - group until predicate holds
 
 Returns:
 
 Traversable batched into Vectors determined by the predicate supplied
 - groupedUntil
```
public HashSet<Vector<T>> groupedUntil(java.util.function.BiPredicate<Vector<? 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)
 .groupedUntil((s,i)->s.contains(4) ? true : false)
 .toList().size(),equalTo(5));
 
 
```
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Specified by:
 
 groupedUntil in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - zipWithStream
```
public  HashSet<Tuple2<T,U>> zipWithStream(java.util.stream.Stream<? extends U> other)
```
 Specified by:
 
 zipWithStream in interface IterableX<T>
 
 Specified by:
 
 zipWithStream in interface Traversable<T>
 
 Specified by:
 
 zipWithStream in interface ImmutableSet<T>
 - groupedWhile
```
public HashSet<Vector<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 IterableX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Specified by:
 
 groupedWhile in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 Returns:
 
 SequenceM batched into lists determined by the predicate supplied
 - groupedWhile
```
public <C extends PersistentCollection<? super T>> HashSet<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)
 .groupedWhile(i->i%3!=0)
 .toList()
 .size(),equalTo(2));
 
 
```
 Specified by:
 
 groupedWhile in interface IterableX<T>
 
 Specified by:
 
 groupedWhile in interface Traversable<T>
 
 Specified by:
 
 groupedWhile in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - Batch while predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - groupedUntil
```
public <C extends PersistentCollection<? super T>> HashSet<C> groupedUntil(java.util.function.Predicate<? super T> predicate,
 java.util.function.Supplier<C> factory)
```
 Description copied from interface: Traversable
 Create a ReactiveSeq batched by a Collection, where each batch is populated until the predicate holds
```
 
 ReactiveSeq.of(1,2,3,4,5,6)
 .groupedUntil(i->i%3!=0)
 .toList()

 //2
 
 
```
 Specified by:
 
 groupedUntil in interface IterableX<T>
 
 Specified by:
 
 groupedUntil in interface Traversable<T>
 
 Specified by:
 
 groupedUntil in interface ImmutableSet<T>
 
 Parameters:
 
 predicate - Batch until predicate holds, applyHKT open next batch
 
 factory - Collection factory
 
 Returns:
 
 SequenceM batched into collections determined by the predicate supplied
 - grouped
```
public HashSet<Vector<T>> grouped(int groupSize)
```
 Description copied from interface: Traversable
 Group elements in a Stream
```
 
 List<List<Integer>> list = ReactiveSeq.of(1, 2, 3, 4, 5, 6).grouped(3).collect(CyclopsCollectors.toList());

 assertThat(list.getValue(0), hasItems(1, 2, 3));
 assertThat(list.getValue(1), hasItems(4, 5, 6));

 
 
```
 Specified by:
 
 grouped in interface IterableX<T>
 
 Specified by:
 
 grouped in interface Traversable<T>
 
 Specified by:
 
 grouped in interface ImmutableSet<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - distinct
```
public HashSet<T> distinct()
```
 Specified by:
 
 distinct in interface IterableX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 
 Specified by:
 
 distinct in interface ImmutableSet<T>
 - scanLeft
```
public HashSet<T> scanLeft(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan left using supplied Monoid
```
 {@code

 ReactiveSeq.of("a", "b", "c")
 .scanLeft(Reducers.toString(""))
 .toList();
 //asList("", "a", "ab", "abc")

 
```
 Specified by:
 
 scanLeft in interface IterableX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Specified by:
 
 scanLeft in interface ImmutableSet<T>
 
 Returns:
 - scanLeft
```
public  HashSet scanLeft(U seed,
 java.util.function.BiFunction<? super U,? super T,? extends U> function)
```
 Description copied from interface: Traversable
 Scan left
```
 
 ReactiveSeq.of("a", "b", "c")
 .scanLeft("", String::concat)
 .toList();
 //[, a, ab, abc]
 
 
```
 Specified by:
 
 scanLeft in interface IterableX<T>
 
 Specified by:
 
 scanLeft in interface Traversable<T>
 
 Specified by:
 
 scanLeft in interface ImmutableSet<T>
 - scanRight
```
public HashSet<T> scanRight(Monoid<T> monoid)
```
 Description copied from interface: Traversable
 Scan right
```
 
 ReactiveSeq.of("a", "b", "c")
 .scanRight(Monoid.of("", String::concat))
 .toList()

 //asList("", "c", "bc", "abc")
 
 
```
 Specified by:
 
 scanRight in interface IterableX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Specified by:
 
 scanRight in interface ImmutableSet<T>
 - scanRight
```
public  HashSet scanRight(U identity,
 java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
```
 Description copied from interface: Traversable
 Scan right
```
 
 ReactiveSeq.of("a", "ab", "abc")
 .map(str->str.length())
 .scanRight(0, (t, u) -> u + t)
 .toList();
 //asList(0, 3, 5, 6);

 
 
```
 Specified by:
 
 scanRight in interface IterableX<T>
 
 Specified by:
 
 scanRight in interface Traversable<T>
 
 Specified by:
 
 scanRight in interface ImmutableSet<T>
 - sorted
```
public HashSet<T> sorted()
```
 Description copied from interface: Traversable
```
 {@code ReactiveSeq.of(4,3,6,7))
 .sorted()
 .toList()

 //Arrays.asList(3,4,6,7)
 
```
 Specified by:
 
 sorted in interface IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface ImmutableSet<T>
 - sorted
```
public HashSet<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 IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface ImmutableSet<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeUntil
```
public HashSet<T> takeUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes elements from this Traversable until the predicate holds
```
 
 Seq.of(1,2,3).takeUntil(i<2);
 //[1,2]
 
 
```
 Specified by:
 
 takeUntil in interface IterableX<T>
 
 Specified by:
 
 takeUntil in interface Traversable<T>
 
 Specified by:
 
 takeUntil in interface ImmutableSet<T>
 
 Parameters:
 
 p - Predicate to determine when values should be taken until
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropUntil
```
public HashSet<T> dropUntil(java.util.function.Predicate<? super T> p)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops elements from this Traversable until the predicate holds
```
 
 Seq.of(1,2,3).dropUntil(i>2);
 //[3]
 
 
```
 Specified by:
 
 dropUntil in interface IterableX<T>
 
 Specified by:
 
 dropUntil in interface Traversable<T>
 
 Specified by:
 
 dropUntil in interface ImmutableSet<T>
 
 Parameters:
 
 p - Predicate to determine when values should be dropped
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - dropRight
```
public HashSet<T> dropRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that drops the specified number elements from the take of this Traversable
```
 
 Seq.of(1,2,3).dropRight(2);
 //[1]
 
 
```
 Specified by:
 
 dropRight in interface IterableX<T>
 
 Specified by:
 
 dropRight in interface Traversable<T>
 
 Specified by:
 
 dropRight in interface ImmutableSet<T>
 
 Parameters:
 
 num - Drop this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - takeRight
```
public HashSet<T> takeRight(int num)
```
 Description copied from interface: Traversable
 Generate a new Traversable that takes the specified number elements from the take of this Traversable
```
 
 Seq.of(1,2,3).takeRight(2);
 //[2,3]
 
 
```
 Specified by:
 
 takeRight in interface IterableX<T>
 
 Specified by:
 
 takeRight in interface Traversable<T>
 
 Specified by:
 
 takeRight in interface ImmutableSet<T>
 
 Parameters:
 
 num - Take this number of elements from the take of this Traversable
 
 Returns:
 
 Traversable generated by application of the predicate to the elements in this Traversable in order
 - intersperse
```
public HashSet<T> intersperse(T value)
```
 Description copied from interface: Traversable
 Returns a Traversable with a given value interspersed between any two values.
```
 
 ReactiveSeq.of(1, 2, 3, 4).intersperse(0)
 // (1, 0, 2, 0, 3, 0, 4)
 
```
 Specified by:
 
 intersperse in interface IterableX<T>
 
 Specified by:
 
 intersperse in interface Traversable<T>
 
 Specified by:
 
 intersperse in interface ImmutableSet<T>
 - shuffle
```
public HashSet<T> shuffle()
```
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface ImmutableSet<T>
 - shuffle
```
public HashSet<T> shuffle(java.util.Random random)
```
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface ImmutableSet<T>
 - slice
```
public HashSet<T> slice(long from,
 long to)
```
 Specified by:
 
 slice in interface IterableX<T>
 
 Specified by:
 
 slice in interface Traversable<T>
 
 Specified by:
 
 slice in interface ImmutableSet<T>
 - prependStream
```
public HashSet<T> prependStream(java.util.stream.Stream<? extends T> stream)
```
 Specified by:
 
 prependStream in interface IterableX<T>
 
 Specified by:
 
 prependStream in interface Traversable<T>
 
 Specified by:
 
 prependStream in interface ImmutableSet<T>
 - appendAll
```
public HashSet<T> appendAll(T... values)
```
 Specified by:
 
 appendAll in interface IterableX<T>
 
 Specified by:
 
 appendAll in interface Traversable<T>
 
 Specified by:
 
 appendAll in interface ImmutableSet<T>
 - prependAll
```
public HashSet<T> prependAll(T... values)
```
 Description copied from interface: Traversable
```
 
 List<String> result = 	ReactiveSeq.of(1,2,3)
 									 .prependAll(100,200,300)
 									 .map(it ->it+"!!")
 									 .collect(CyclopsCollectors.toList());


 //asList("100!!","200!!","300!!","1!!","2!!","3!!")));
 
```
 Specified by:
 
 prependAll in interface IterableX<T>
 
 Specified by:
 
 prependAll in interface Traversable<T>
 
 Specified by:
 
 prependAll in interface ImmutableSet<T>
 
 Parameters:
 
 values - to prependAll
 
 Returns:
 
 ReactiveSeq with values prepended
 - deleteBetween
```
public HashSet<T> deleteBetween(int start,
 int end)
```
 Description copied from interface: Traversable
 Delete elements between given indexes
```
 {@code
 List result = ReactiveSeq.of(1, 2, 3, 4, 5, 6)
 .deleteBetween(2, 4).map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 //Arrays.asList("1!!", "2!!", "5!!", "6!!")));
 
```
 Specified by:
 
 deleteBetween in interface IterableX<T>
 
 Specified by:
 
 deleteBetween in interface Traversable<T>
 
 Specified by:
 
 deleteBetween in interface ImmutableSet<T>
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertStreamAt
```
public HashSet<T> insertStreamAt(int pos,
 java.util.stream.Stream<T> stream)
```
 Description copied from interface: Traversable
 Insert a Stream into the middle of this traversable at the specified position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .insertAt(1, of(100, 200, 300))
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 //Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")));
 
 
```
 Specified by:
 
 insertStreamAt in interface IterableX<T>
 
 Specified by:
 
 insertStreamAt in interface Traversable<T>
 
 Specified by:
 
 insertStreamAt in interface ImmutableSet<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined Traversable
 - sorted
```
public > HashSet<T> sorted(java.util.function.Function<? super T,? extends U> function)
```
 Specified by:
 
 sorted in interface IterableX<T>
 
 Specified by:
 
 sorted in interface Traversable<T>
 
 Specified by:
 
 sorted in interface ImmutableSet<T>
 - mkString
```
public java.lang.String mkString()
```
 - onEmpty
```
public HashSet<T> onEmpty(T value)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is zero, create a new instance containing the provided value
 
 Specified by:
 
 onEmpty in interface OnEmpty<T>
 
 Specified by:
 
 onEmpty in interface IterableX<T>
 
 Specified by:
 
 onEmpty in interface Traversable<T>
 
 Specified by:
 
 onEmpty in interface ImmutableSet<T>
 
 Returns:
 
 New instance containing value if container is zero, otherwise returns this container
 - onEmptyGet
```
public HashSet<T> onEmptyGet(java.util.function.Supplier<? extends T> supplier)
```
 Description copied from interface: OnEmpty
 
 If this Container instance is zero, create a new instance containing the value returned from the provided Supplier
 
 Specified by:
 
 onEmptyGet in interface OnEmpty<T>
 
 Specified by:
 
 onEmptyGet in interface IterableX<T>
 
 Specified by:
 
 onEmptyGet in interface Traversable<T>
 
 Specified by:
 
 onEmptyGet in interface ImmutableSet<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is zero, otherwise this container
 - removeAll
```
public HashSet<T> removeAll(T... values)
```
 Description copied from interface: IterableFilterable
 
 Remove all supplied elements from this filterable
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface IterableX<T>
 
 Specified by:
 
 removeAll in interface ImmutableSet<T>
 
 Parameters:
 
 values - to removeValue
 
 Returns:
 
 Filters with all supplied values removed
 - prepend
```
public HashSet<T> prepend(T value)
```
 Specified by:
 
 prepend in interface IterableX<T>
 
 Specified by:
 
 prepend in interface Traversable<T>
 
 Specified by:
 
 prepend in interface ImmutableSet<T>
 - removeAt
```
public HashSet<T> removeAt(long pos)
```
 Specified by:
 
 removeAt in interface IterableX<T>
 
 Specified by:
 
 removeAt in interface Traversable<T>
 
 Specified by:
 
 removeAt in interface ImmutableSet<T>
 - prependAll
```
public HashSet<T> prependAll(java.lang.Iterable<? extends T> value)
```
 Specified by:
 
 prependAll in interface IterableX<T>
 
 Specified by:
 
 prependAll in interface Traversable<T>
 
 Specified by:
 
 prependAll in interface ImmutableSet<T>
 - updateAt
```
public HashSet<T> updateAt(int pos,
 T value)
```
 Specified by:
 
 updateAt in interface IterableX<T>
 
 Specified by:
 
 updateAt in interface Traversable<T>
 
 Specified by:
 
 updateAt in interface ImmutableSet<T>
 - insertAt
```
public HashSet<T> insertAt(int pos,
 java.lang.Iterable<? extends T> values)
```
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Specified by:
 
 insertAt in interface ImmutableSet<T>
 - insertAt
```
public HashSet<T> insertAt(int i,
 T value)
```
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface ImmutableSet<T>
 - insertAt
```
public HashSet<T> insertAt(int pos,
 T... values)
```
 Description copied from interface: Traversable
 Insert data into a traversable at given position
```
 
 List<String> result = ReactiveSeq.of(1, 2, 3)
 .insertAt(1, 100, 200, 300)
 .map(it -> it + "!!")
 .collect(CyclopsCollectors.toList());

 //Arrays.asList("1!!", "100!!", "200!!", "300!!", "2!!", "3!!")))
 
 
```
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface Traversable<T>
 
 Specified by:
 
 insertAt in interface ImmutableSet<T>
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Traversable with new data inserted

Class HashSet<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.data.ImmutableSet

Methods inherited from interface com.oath.cyclops.types.persistent.PersistentSet

Methods inherited from interface com.oath.cyclops.types.foldable.Contains

Methods inherited from interface com.oath.cyclops.types.traversable.IterableX

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

Methods inherited from interface java.lang.Iterable

Methods inherited from interface com.oath.cyclops.types.foldable.Folds

Methods inherited from interface com.oath.cyclops.hkt.Higher

Methods inherited from interface com.oath.cyclops.hkt.Convert

Constructor Detail

HashSet

Method Detail

empty

singleton

of

unfold

iterate

iterate

unzip

generate

generate

range

range

rangeLong

rangeLong

fromStream

fromIterable

fromIterator

unitIterable

containsValue

size

add

removeValue

isEmpty

map

flatMap

concatMap

mergeMap

mergeMap

forEach4

forEach4

forEach3

forEach3

forEach2

forEach2

filter

unitStream

plus

plusAll

removeAll

stream

iterator

equals

hashCode

toString

take

takeWhile

dropWhile

drop

reverse

duplicate

unzip

removeFirst

append

appendAll

foldLeft

ofType

filterNot

notNull

peek

removeStream

retainAll

retainStream

retainAll

permutations

combinations