TreeSet (cyclops 10.3.2 API)

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

All Implemented Interfaces:

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

Serialized Form

Constructor Summary

Constructors
Constructor and Description

TreeSet(RedBlackTree.Tree<T,T> map, java.util.Comparator<? super T> comp)

Constructors
Constructor and Description
`TreeSet(RedBlackTree.Tree<T,T> map, java.util.Comparator<? super T> comp)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`TreeSet<T>`	`add(T value)`
`TreeSet<T>`	`append(T append)`
`TreeSet<T>`	`appendAll(java.lang.Iterable<? extends T> it)`
`TreeSet<T>`	`appendAll(T... values)`
`TreeSet<ReactiveSeq<T>>`	`combinations()`
`TreeSet<ReactiveSeq<T>>`	`combinations(int size)`
`TreeSet<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.
`TreeSet<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.
`java.util.Comparator<? super T>`	`comparator()`
`<R> TreeSet<R>`	`concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn)` Perform a flatMap operation on this IterableX.
`<R> TreeSet<R>`	`concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn, java.util.Comparator<? super R> comp)`
`boolean`	`containsValue(T value)`
`TreeSet<T>`	`cycle(long times)`
`TreeSet<T>`	`cycle(Monoid<T> m, long times)`
`TreeSet<T>`	`cycleUntil(java.util.function.Predicate<? super T> predicate)`
`TreeSet<T>`	`cycleWhile(java.util.function.Predicate<? super T> predicate)`
`TreeSet<T>`	`deleteBetween(int start, int end)` Delete elements between given indexes
`TreeSet<T>`	`distinct()`
`ImmutableSortedSet<T>`	`drop(int num)`
`TreeSet<T>`	`drop(long num)` `assertThat(ReactiveSeq.of(4,3,6,7).drop(2).toList(),equalTo(Arrays.asList(6,7)));`
`TreeSet<T>`	`dropRight(int num)` Generate a new Traversable that drops the specified number elements from the take of this Traversable
`TreeSet<T>`	`dropUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that drops elements from this Traversable until the predicate holds
`TreeSet<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<TreeSet<T>,TreeSet<T>>`	`duplicate()`
`static <T extends java.lang.Comparable<? super T>> TreeSet<T>`	`empty()`
`static <T> TreeSet<T>`	`empty(java.util.Comparator<? super T> comp)`
`boolean`	`equals(java.lang.Object o)`
`TreeSet<T>`	`filter(java.util.function.Predicate<? super T> predicate)` Keep only elements for which the supplied predicates hold e.g.
`TreeSet<T>`	`filterNot(java.util.function.Predicate<? super T> predicate)` Remove any elements for which the predicate holds (inverse operation to filter) e.g.
`Option<T>`	`first()`
`<R> TreeSet<R>`	`flatMap(java.util.function.Function<? super T,? extends ImmutableSet<? extends R>> fn)`
`<R> TreeSet<R>`	`flatMap(java.util.function.Function<? super T,? extends ImmutableSet<? extends R>> fn, java.util.Comparator<? super R> comp)`
`<R> R`	`foldLeft(R zero, java.util.function.BiFunction<R,? super T,R> f)`
`<R1,R> TreeSet<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> TreeSet<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> TreeSet<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> TreeSet<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> TreeSet<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> TreeSet<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 extends java.lang.Comparable<? super T>> TreeSet<T>`	`fromIterable(java.lang.Iterable<T> it)`
`static <T> TreeSet<T>`	`fromIterable(java.lang.Iterable<T> it, java.util.Comparator<? super T> comp)`
`static <T> TreeSet<T>`	`fromSortedSet(java.util.SortedSet<T> set, java.util.Comparator<? super T> comp)`
`static <T> TreeSet<T>`	`fromStream(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comp)`
`Option<T>`	`get(int index)`
`TreeSet<Vector<T>>`	`grouped(int groupSize)` Group elements in a Stream
`<C extends PersistentCollection<? super T>> TreeSet<C>`	`grouped(int size, java.util.function.Supplier<C> supplier)` Group the elements of this traversable
`TreeSet<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.
`TreeSet<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>> TreeSet<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
`TreeSet<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>> TreeSet<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()`
`TreeSet<T>`	`insertAt(int pos, java.lang.Iterable<? extends T> values)`
`TreeSet<T>`	`insertAt(int pos, T... values)` Insert data into a traversable at given position
`TreeSet<T>`	`insertAt(int i, T value)`
`TreeSet<T>`	`insertStreamAt(int pos, java.util.stream.Stream<T> stream)` Insert a Stream into the middle of this traversable at the specified position
`TreeSet<T>`	`intersperse(T value)` Returns a Traversable with a given value interspersed between any two values.
`boolean`	`isEmpty()`
`java.util.Iterator<T>`	`iterator()`
`Option<T>`	`last()`
`<R> TreeSet<R>`	`map(java.util.function.Function<? super T,? extends R> fn)` Transform this functor using the supplied transformation function
`<R> TreeSet<R>`	`map(java.util.function.Function<? super T,? extends R> fn, java.util.Comparator<? super R> comp)`
`<R> TreeSet<R>`	`mergeMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`<R> TreeSet<R>`	`mergeMap(int maxConcurecy, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> fn)`
`java.lang.String`	`mkString()`
`TreeSet<T>`	`notNull()` Filter elements retaining only values which are not null
`static <T> TreeSet<T>`	`of(java.util.Comparator<? super T> comp, T... values)`
`static <T extends java.lang.Comparable<? super T>> TreeSet<T>`	`of(T... values)`
`<U> TreeSet<U>`	`ofType(java.lang.Class<? extends U> type)` Keep only those elements in a stream that are of a given type.
`TreeSet<T>`	`onEmpty(T value)` If this Container instance is zero, create a new instance containing the provided value
`TreeSet<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
`TreeSet<T>`	`peek(java.util.function.Consumer<? super T> c)` Peek at the current value of this Transformable, without transforming it
`TreeSet<ReactiveSeq<T>>`	`permutations()`
`TreeSet<T>`	`plus(T value)`
`TreeSet<T>`	`plusAll(java.lang.Iterable<? extends T> list)`
`TreeSet<T>`	`prepend(T value)`
`TreeSet<T>`	`prependAll(java.lang.Iterable<? extends T> value)`
`TreeSet<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!!")));`
`TreeSet<T>`	`prependStream(java.util.stream.Stream<? extends T> stream)`
`java.lang.String`	`printTree()`
`TreeSet<T>`	`removeAll(java.lang.Iterable<? extends T> list)` Remove all elements in the supplied Iterable from this filterable
`TreeSet<T>`	`removeAll(T... values)` Remove all supplied elements from this filterable
`TreeSet<T>`	`removeAt(long pos)`
`TreeSet<T>`	`removeFirst(java.util.function.Predicate<? super T> pred)`
`TreeSet<T>`	`removeStream(java.util.stream.Stream<? extends T> stream)` Remove all elements in the supplied Stream from this filterable
`TreeSet<T>`	`removeValue(T value)`
`TreeSet<T>`	`retainAll(java.lang.Iterable<? extends T> it)` Retain only the supplied elements in the returned Filters
`TreeSet<T>`	`retainAll(T... values)` Retain only the supplied elements in the returned Filters
`TreeSet<T>`	`retainStream(java.util.stream.Stream<? extends T> stream)` Retain only the supplied elements in the returned Filters
`TreeSet<T>`	`reverse()`
`TreeSet<T>`	`scanLeft(Monoid<T> monoid)` Scan left using supplied Monoid
`<U> TreeSet<U>`	`scanLeft(U seed, java.util.function.BiFunction<? super U,? super T,? extends U> function)` Scan left
`TreeSet<T>`	`scanRight(Monoid<T> monoid)` Scan right
`<U> TreeSet<U>`	`scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)` Scan right
`TreeSet<T>`	`shuffle()`
`TreeSet<T>`	`shuffle(java.util.Random random)`
`static <T> TreeSet<T>`	`singleton(java.util.Comparator<? super T> comp, T value)`
`static <T extends java.lang.Comparable<? super T>> TreeSet<T>`	`singleton(T value)`
`int`	`size()`
`TreeSet<T>`	`slice(long from, long to)`
`TreeSet<Seq<T>>`	`sliding(int windowSize)` Create a sliding view
`TreeSet<Seq<T>>`	`sliding(int windowSize, int increment)` Create a sliding view
`TreeSet<T>`	`sorted()` {@code ReactiveSeq.of(4,3,6,7)) .sorted() .toList() //Arrays.asList(3,4,6,7)
`TreeSet<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>> TreeSet<T>`	`sorted(java.util.function.Function<? super T,? extends U> function)`
`ReactiveSeq<T>`	`stream()`
`ImmutableSortedSet<T>`	`subSet(T fromElement, T toElement)`
`ImmutableSortedSet<T>`	`take(int num)`
`TreeSet<T>`	`take(long n)` {@code ReactiveSeq.of(4,3,6,7) .take(2) .toList() asList(4,3)
`TreeSet<T>`	`takeRight(int num)` Generate a new Traversable that takes the specified number elements from the take of this Traversable
`TreeSet<T>`	`takeUntil(java.util.function.Predicate<? super T> p)` Generate a new Traversable that takes elements from this Traversable until the predicate holds
`TreeSet<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()`
`<R> TreeSet<R>`	`unitIterable(java.lang.Iterable<R> it)`
`<R> TreeSet<R>`	`unitStream(java.util.stream.Stream<R> stream)`
`ImmutableSortedSet<T>`	`unitStream(java.util.stream.Stream<T> stream, java.util.Comparator<? super T> comp)`
`<R1,R2> Tuple2<TreeSet<R1>,TreeSet<R2>>`	`unzip(java.util.function.Function<? super T,Tuple2<? extends R1,? extends R2>> fn)`
`TreeSet<T>`	`updateAt(int pos, T value)`
`<T2,R> TreeSet<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> TreeSet<Tuple2<T,U>>`	`zip(java.lang.Iterable<? extends U> other)`
`<U,R> TreeSet<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> TreeSet<Tuple3<T,S,U>>`	`zip3(java.lang.Iterable<? extends S> second, java.lang.Iterable<? extends U> third)`
`<S,U,R> TreeSet<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> TreeSet<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> TreeSet<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)`
`TreeSet<Tuple2<T,java.lang.Long>>`	`zipWithIndex()`
`<U> TreeSet<Tuple2<T,U>>`	`zipWithPublisher(org.reactivestreams.Publisher<? extends U> other)`
`<U> TreeSet<Tuple2<T,U>>`	`zipWithStream(java.util.stream.Stream<? extends U> other)`
`<U,R> TreeSet<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.ImmutableSortedSet
partition, span, splitAt, splitBy, traversable

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

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.types.persistent.PersistentSortedSet
sortedSetView

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

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

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

- Constructor Detail
 - TreeSet
```
public TreeSet(RedBlackTree.Tree<T,T> map,
 java.util.Comparator<? super T> comp)
```
- Method Detail
 - empty
```
public static <T extends java.lang.Comparable<? super T>> TreeSet<T> empty()
```
 - singleton
```
public static <T extends java.lang.Comparable<? super T>> TreeSet<T> singleton(T value)
```
 - singleton
```
public static <T> TreeSet<T> singleton(java.util.Comparator<? super T> comp,
 T value)
```
 - empty
```
public static <T> TreeSet<T> empty(java.util.Comparator<? super T> comp)
```
 - fromStream
```
public static <T> TreeSet<T> fromStream(java.util.stream.Stream<T> stream,
 java.util.Comparator<? super T> comp)
```
 - fromIterable
```
public static <T> TreeSet<T> fromIterable(java.lang.Iterable<T> it,
 java.util.Comparator<? super T> comp)
```
 - fromIterable
```
public static <T extends java.lang.Comparable<? super T>> TreeSet<T> fromIterable(java.lang.Iterable<T> it)
```
 - unitIterable
```
public <R> TreeSet<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>
 
 Specified by:
 
 unitIterable in interface ImmutableSortedSet<T>
 - 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>
 
 Specified by:
 
 stream in interface ImmutableSortedSet<T>
 
 Returns:
 
 This Traversable converted to a Stream
 - of
```
public static <T> TreeSet<T> of(java.util.Comparator<? super T> comp,
 T... values)
```
 - of
```
public static <T extends java.lang.Comparable<? super T>> TreeSet<T> of(T... values)
```
 - fromSortedSet
```
public static <T> TreeSet<T> fromSortedSet(java.util.SortedSet<T> set,
 java.util.Comparator<? super T> comp)
```
 - 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 TreeSet<T> add(T value)
```
 Specified by:
 
 add in interface ImmutableSet<T>
 
 Specified by:
 
 add in interface ImmutableSortedSet<T>
 - removeValue
```
public TreeSet<T> removeValue(T value)
```
 Specified by:
 
 removeValue in interface PersistentCollection<T>
 
 Specified by:
 
 removeValue in interface PersistentSet<T>
 
 Specified by:
 
 removeValue in interface PersistentSortedSet<T>
 
 Specified by:
 
 removeValue in interface IterableX<T>
 
 Specified by:
 
 removeValue in interface ImmutableSet<T>
 
 Specified by:
 
 removeValue in interface ImmutableSortedSet<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> TreeSet<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>
 
 Specified by:
 
 map in interface ImmutableSortedSet<T>
 
 Parameters:
 
 fn - Transformation function
 
 Returns:
 
 Transformed Transformable
 - map
```
public <R> TreeSet<R> map(java.util.function.Function<? super T,? extends R> fn,
 java.util.Comparator<? super R> comp)
```
 - flatMap
```
public <R> TreeSet<R> flatMap(java.util.function.Function<? super T,? extends ImmutableSet<? extends R>> fn)
```
 Specified by:
 
 flatMap in interface ImmutableSet<T>
 
 Specified by:
 
 flatMap in interface ImmutableSortedSet<T>
 - flatMap
```
public <R> TreeSet<R> flatMap(java.util.function.Function<? super T,? extends ImmutableSet<? extends R>> fn,
 java.util.Comparator<? super R> comp)
```
 - concatMap
```
public <R> TreeSet<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>
 
 Specified by:
 
 concatMap in interface ImmutableSortedSet<T>
 
 Parameters:
 
 fn - Transformation function to be applied (and flattened)
 
 Returns:
 
 An IterableX containing the flattened results of the transformation function
 - mergeMap
```
public <R> TreeSet<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>
 
 Specified by:
 
 mergeMap in interface ImmutableSortedSet<T>
 - mergeMap
```
public <R> TreeSet<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>
 
 Specified by:
 
 mergeMap in interface ImmutableSortedSet<T>
 - concatMap
```
public <R> TreeSet<R> concatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> fn,
 java.util.Comparator<? super R> comp)
```
 - filter
```
public TreeSet<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>
 
 Specified by:
 
 filter in interface ImmutableSortedSet<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - unitStream
```
public <R> TreeSet<R> unitStream(java.util.stream.Stream<R> stream)
```
 Specified by:
 
 unitStream in interface ImmutableSet<T>
 
 Specified by:
 
 unitStream in interface ImmutableSortedSet<T>
 - unitStream
```
public ImmutableSortedSet<T> unitStream(java.util.stream.Stream<T> stream,
 java.util.Comparator<? super T> comp)
```
 Specified by:
 
 unitStream in interface ImmutableSortedSet<T>
 - plus
```
public TreeSet<T> plus(T value)
```
 Specified by:
 
 plus in interface PersistentCollection<T>
 
 Specified by:
 
 plus in interface PersistentSet<T>
 
 Specified by:
 
 plus in interface PersistentSortedSet<T>
 
 Specified by:
 
 plus in interface IterableX<T>
 
 Specified by:
 
 plus in interface ImmutableSet<T>
 
 Specified by:
 
 plus in interface ImmutableSortedSet<T>
 - plusAll
```
public TreeSet<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 PersistentSortedSet<T>
 
 Specified by:
 
 plusAll in interface IterableX<T>
 
 Specified by:
 
 plusAll in interface ImmutableSet<T>
 
 Specified by:
 
 plusAll in interface ImmutableSortedSet<T>
 - removeAll
```
public TreeSet<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 PersistentSortedSet<T>
 
 Specified by:
 
 removeAll in interface IterableFilterable<T>
 
 Specified by:
 
 removeAll in interface IterableX<T>
 
 Specified by:
 
 removeAll in interface ImmutableSet<T>
 
 Specified by:
 
 removeAll in interface ImmutableSortedSet<T>
 
 Parameters:
 
 list - an Iterable of elements to removeValue
 
 Returns:
 
 Filters with all supplied elements removed
 - get
```
public Option<T> get(int index)
```
 Specified by:
 
 get in interface PersistentSortedSet<T>
 - iterator
```
public java.util.Iterator<T> iterator()
```
 Specified by:
 
 iterator in interface java.lang.Iterable<T>
 - comparator
```
public java.util.Comparator<? super T> comparator()
```
 Specified by:
 
 comparator in interface PersistentSortedSet<T>
 
 Specified by:
 
 comparator in interface ImmutableSortedSet<T>
 - subSet
```
public ImmutableSortedSet<T> subSet(T fromElement,
 T toElement)
```
 Specified by:
 
 subSet in interface ImmutableSortedSet<T>
 - first
```
public Option<T> first()
```
 Specified by:
 
 first in interface ImmutableSortedSet<T>
 - last
```
public Option<T> last()
```
 Specified by:
 
 last in interface ImmutableSortedSet<T>
 - drop
```
public ImmutableSortedSet<T> drop(int num)
```
 Specified by:
 
 drop in interface ImmutableSortedSet<T>
 - take
```
public ImmutableSortedSet<T> take(int num)
```
 Specified by:
 
 take in interface ImmutableSortedSet<T>
 - printTree
```
public java.lang.String printTree()
```
 - 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 TreeSet<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>
 
 Specified by:
 
 take in interface ImmutableSortedSet<T>
 
 Parameters:
 
 n - Elements to take
 
 Returns:
 
 Traversable with specified number of elements
 - takeWhile
```
public TreeSet<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>
 
 Specified by:
 
 takeWhile in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 dropWhile in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 drop in interface ImmutableSortedSet<T>
 
 Parameters:
 
 num - Number of elemenets to drop
 
 Returns:
 
 Traversable with specified number of elements skipped
 - reverse
```
public TreeSet<T> reverse()
```
 Specified by:
 
 reverse in interface IterableX<T>
 
 Specified by:
 
 reverse in interface Traversable<T>
 
 Specified by:
 
 reverse in interface ImmutableSet<T>
 
 Specified by:
 
 reverse in interface ImmutableSortedSet<T>
 - duplicate
```
public Tuple2<TreeSet<T>,TreeSet<T>> duplicate()
```
 - unzip
```
public <R1,R2> Tuple2<TreeSet<R1>,TreeSet<R2>> unzip(java.util.function.Function<? super T,Tuple2<? extends R1,? extends R2>> fn)
```
 - removeFirst
```
public TreeSet<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 TreeSet<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>
 
 Specified by:
 
 append in interface ImmutableSortedSet<T>
 - appendAll
```
public TreeSet<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  TreeSet 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>
 
 Specified by:
 
 ofType in interface ImmutableSortedSet<T>
 - filterNot
```
public TreeSet<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>
 
 Specified by:
 
 filterNot in interface ImmutableSortedSet<T>
 
 Parameters:
 
 predicate - to filter elements by, retaining matches
 
 Returns:
 
 Filters with elements removed where the predicate does not hold
 - notNull
```
public TreeSet<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>
 
 Specified by:
 
 notNull in interface ImmutableSortedSet<T>
 
 Returns:
 
 Filters with nulls removed
 - peek
```
public TreeSet<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>
 
 Specified by:
 
 peek in interface ImmutableSortedSet<T>
 
 Parameters:
 
 c - Consumer that recieves each element from this Transformable
 
 Returns:
 
 Transformable that will peek at each value
 - removeStream
```
public TreeSet<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>
 
 Specified by:
 
 removeStream in interface ImmutableSortedSet<T>
 
 Parameters:
 
 stream - of elements to remove
 
 Returns:
 
 Filters with all supplied elements removed
 - retainAll
```
public TreeSet<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>
 
 Specified by:
 
 retainAll in interface ImmutableSortedSet<T>
 
 Parameters:
 
 it - Iterable of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainStream
```
public TreeSet<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>
 
 Specified by:
 
 retainStream in interface ImmutableSortedSet<T>
 
 Parameters:
 
 stream - of elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - retainAll
```
public TreeSet<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>
 
 Specified by:
 
 retainAll in interface ImmutableSortedSet<T>
 
 Parameters:
 
 values - elements to retain
 
 Returns:
 
 Filters with supplied values retained, and others removed
 - permutations
```
public TreeSet<ReactiveSeq<T>> permutations()
```
 Specified by:
 
 permutations in interface IterableX<T>
 
 Specified by:
 
 permutations in interface ImmutableSet<T>
 
 Specified by:
 
 permutations in interface ImmutableSortedSet<T>
 - combinations
```
public TreeSet<ReactiveSeq<T>> combinations(int size)
```
 Specified by:
 
 combinations in interface IterableX<T>
 
 Specified by:
 
 combinations in interface ImmutableSet<T>
 
 Specified by:
 
 combinations in interface ImmutableSortedSet<T>
 - combinations
```
public TreeSet<ReactiveSeq<T>> combinations()
```
 Specified by:
 
 combinations in interface IterableX<T>
 
 Specified by:
 
 combinations in interface ImmutableSet<T>
 
 Specified by:
 
 combinations in interface ImmutableSortedSet<T>
 - zip
```
public <T2,R> TreeSet<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>
 
 Specified by:
 
 zip in interface ImmutableSortedSet<T>
 
 Parameters:
 
 fn - Zip / combining function
 
 publisher - to combine with
 
 Returns:
 
 Combined zippable
 - zipWithStream
```
public <U,R> TreeSet<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>
 
 Specified by:
 
 zipWithStream in interface ImmutableSortedSet<T>
 - zipWithPublisher
```
public  TreeSet<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>
 
 Specified by:
 
 zipWithPublisher in interface ImmutableSortedSet<T>
 - zip
```
public  TreeSet<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>
 
 Specified by:
 
 zip in interface ImmutableSortedSet<T>
 - zip3
```
public <S,U,R> TreeSet<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>
 
 Specified by:
 
 zip3 in interface ImmutableSortedSet<T>
 - zip4
```
public <T2,T3,T4,R> TreeSet<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>
 
 Specified by:
 
 zip4 in interface ImmutableSortedSet<T>
 - combine
```
public TreeSet<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>
 
 Specified by:
 
 combine in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 combine in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 cycle in interface ImmutableSortedSet<T>
 - cycle
```
public TreeSet<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>
 
 Specified by:
 
 cycle in interface ImmutableSortedSet<T>
 - cycleWhile
```
public TreeSet<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>
 
 Specified by:
 
 cycleWhile in interface ImmutableSortedSet<T>
 - cycleUntil
```
public TreeSet<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>
 
 Specified by:
 
 cycleUntil in interface ImmutableSortedSet<T>
 - zip
```
public <U,R> TreeSet<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>
 
 Specified by:
 
 zip in interface ImmutableSortedSet<T>
 
 Parameters:
 
 other - to zip with
 
 zipper - Zip function
 
 Returns:
 
 Combined zippable
 - zip3
```
public <S,U> TreeSet<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>
 
 Specified by:
 
 zip3 in interface ImmutableSortedSet<T>
 - zip4
```
public <T2,T3,T4> TreeSet<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>
 
 Specified by:
 
 zip4 in interface ImmutableSortedSet<T>
 - zipWithIndex
```
public TreeSet<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>
 
 Specified by:
 
 zipWithIndex in interface ImmutableSortedSet<T>
 - sliding
```
public TreeSet<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>
 
 Specified by:
 
 sliding in interface ImmutableSortedSet<T>
 - sliding
```
public TreeSet<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>
 
 Specified by:
 
 sliding in interface ImmutableSortedSet<T>
 - grouped
```
public <C extends PersistentCollection<? super T>> TreeSet<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>
 
 Specified by:
 
 grouped in interface ImmutableSortedSet<T>
 
 Parameters:
 
 size - batch size
 
 supplier - Collection factory
 
 Returns:
 
 Traversable grouped by size
 - groupedUntil
```
public TreeSet<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>
 
 Specified by:
 
 groupedUntil in interface ImmutableSortedSet<T>
 
 Parameters:
 
 predicate - group until predicate holds
 
 Returns:
 
 Traversable batched into Vectors determined by the predicate supplied
 - groupedUntil
```
public TreeSet<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>
 
 Specified by:
 
 groupedUntil in interface ImmutableSortedSet<T>
 
 Parameters:
 
 predicate - Window while true
 
 Returns:
 
 Traversable windowed while predicate holds
 - zipWithStream
```
public  TreeSet<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>
 
 Specified by:
 
 zipWithStream in interface ImmutableSortedSet<T>
 - groupedWhile
```
public TreeSet<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>
 
 Specified by:
 
 groupedWhile in interface ImmutableSortedSet<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>> TreeSet<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>
 
 Specified by:
 
 groupedWhile in interface ImmutableSortedSet<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>> TreeSet<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>
 
 Specified by:
 
 groupedUntil in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 grouped in interface ImmutableSortedSet<T>
 
 Parameters:
 
 groupSize - Size of each Group
 
 Returns:
 
 Stream with elements grouped by size
 - distinct
```
public TreeSet<T> distinct()
```
 Specified by:
 
 distinct in interface IterableX<T>
 
 Specified by:
 
 distinct in interface Traversable<T>
 
 Specified by:
 
 distinct in interface ImmutableSet<T>
 
 Specified by:
 
 distinct in interface ImmutableSortedSet<T>
 - scanLeft
```
public TreeSet<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>
 
 Specified by:
 
 scanLeft in interface ImmutableSortedSet<T>
 
 Returns:
 - scanLeft
```
public  TreeSet 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>
 
 Specified by:
 
 scanLeft in interface ImmutableSortedSet<T>
 - scanRight
```
public TreeSet<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>
 
 Specified by:
 
 scanRight in interface ImmutableSortedSet<T>
 - scanRight
```
public  TreeSet 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>
 
 Specified by:
 
 scanRight in interface ImmutableSortedSet<T>
 - sorted
```
public TreeSet<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>
 
 Specified by:
 
 sorted in interface ImmutableSortedSet<T>
 - sorted
```
public TreeSet<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>
 
 Specified by:
 
 sorted in interface ImmutableSortedSet<T>
 
 Parameters:
 
 c - Compartor to sort with
 
 Returns:
 
 Sorted Stream
 - takeUntil
```
public TreeSet<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>
 
 Specified by:
 
 takeUntil in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 dropUntil in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 dropRight in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 takeRight in interface ImmutableSortedSet<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 TreeSet<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>
 
 Specified by:
 
 intersperse in interface ImmutableSortedSet<T>
 - shuffle
```
public TreeSet<T> shuffle()
```
 Specified by:
 
 shuffle in interface IterableX<T>
 
 Specified by:
 
 shuffle in interface Traversable<T>
 
 Specified by:
 
 shuffle in interface ImmutableSet<T>
 
 Specified by:
 
 shuffle in interface ImmutableSortedSet<T>
 - shuffle
```
public TreeSet<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>
 
 Specified by:
 
 shuffle in interface ImmutableSortedSet<T>
 - slice
```
public TreeSet<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>
 
 Specified by:
 
 slice in interface ImmutableSortedSet<T>
 - prependStream
```
public TreeSet<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>
 
 Specified by:
 
 prependStream in interface ImmutableSortedSet<T>
 - appendAll
```
public TreeSet<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>
 
 Specified by:
 
 appendAll in interface ImmutableSortedSet<T>
 - prependAll
```
public TreeSet<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>
 
 Specified by:
 
 prependAll in interface ImmutableSortedSet<T>
 
 Parameters:
 
 values - to prependAll
 
 Returns:
 
 ReactiveSeq with values prepended
 - deleteBetween
```
public TreeSet<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>
 
 Specified by:
 
 deleteBetween in interface ImmutableSortedSet<T>
 
 Parameters:
 
 start - index
 
 end - index
 
 Returns:
 
 Stream with elements removed
 - insertStreamAt
```
public TreeSet<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>
 
 Specified by:
 
 insertStreamAt in interface ImmutableSortedSet<T>
 
 Parameters:
 
 pos - to insert Stream at
 
 stream - to insert
 
 Returns:
 
 newly conjoined Traversable
 - sorted
```
public > TreeSet<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>
 
 Specified by:
 
 sorted in interface ImmutableSortedSet<T>
 - mkString
```
public java.lang.String mkString()
```
 - onEmpty
```
public TreeSet<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>
 
 Specified by:
 
 onEmpty in interface ImmutableSortedSet<T>
 
 Returns:
 
 New instance containing value if container is zero, otherwise returns this container
 - onEmptyGet
```
public TreeSet<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>
 
 Specified by:
 
 onEmptyGet in interface ImmutableSortedSet<T>
 
 Parameters:
 
 supplier - to determine new value for container
 
 Returns:
 
 New Container with value if this is zero, otherwise this container
 - removeAll
```
public TreeSet<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>
 
 Specified by:
 
 removeAll in interface ImmutableSortedSet<T>
 
 Parameters:
 
 values - to removeValue
 
 Returns:
 
 Filters with all supplied values removed
 - prepend
```
public TreeSet<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>
 
 Specified by:
 
 prepend in interface ImmutableSortedSet<T>
 - removeAt
```
public TreeSet<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 TreeSet<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>
 - forEach4
```
public <R1,R2,R3,R> TreeSet<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>
 
 Specified by:
 
 forEach4 in interface ImmutableSortedSet<T>
 - forEach4
```
public <R1,R2,R3,R> TreeSet<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>
 
 Specified by:
 
 forEach4 in interface ImmutableSortedSet<T>
 - forEach3
```
public <R1,R2,R> TreeSet<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>
 
 Specified by:
 
 forEach3 in interface ImmutableSortedSet<T>
 - forEach3
```
public <R1,R2,R> TreeSet<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>
 
 Specified by:
 
 forEach3 in interface ImmutableSortedSet<T>
 - forEach2
```
public <R1,R> TreeSet<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>
 
 Specified by:
 
 forEach2 in interface ImmutableSortedSet<T>
 - forEach2
```
public <R1,R> TreeSet<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>
 
 Specified by:
 
 forEach2 in interface ImmutableSortedSet<T>
 - updateAt
```
public TreeSet<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 TreeSet<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 TreeSet<T> insertAt(int i,
 T value)
```
 Specified by:
 
 insertAt in interface IterableX<T>
 
 Specified by:
 
 insertAt in interface ImmutableSet<T>
 - insertAt
```
public TreeSet<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>
 
 Specified by:
 
 insertAt in interface ImmutableSortedSet<T>
 
 Parameters:
 
 pos - to insert data at
 
 values - to insert
 
 Returns:
 
 Traversable with new data inserted

Class TreeSet<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cyclops.data.ImmutableSortedSet

Methods inherited from interface cyclops.data.ImmutableSet

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.types.persistent.PersistentSortedSet

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

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

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

Constructor Detail

TreeSet

Method Detail

empty

singleton

singleton

empty

fromStream

fromIterable

fromIterable

unitIterable

stream

of

of

fromSortedSet

containsValue

size

add

removeValue

isEmpty

map

map

flatMap

flatMap

concatMap

mergeMap

mergeMap

concatMap

filter

unitStream

unitStream

plus

plusAll

removeAll

get

iterator

comparator

subSet

first

last

drop

take

printTree

equals

hashCode

toString

take

takeWhile

dropWhile

drop

reverse

duplicate

unzip

removeFirst

append

appendAll

foldLeft

ofType

filterNot

notNull

peek

removeStream

retainAll

retainStream

retainAll