ISet

All Superinterfaces:

ICollection<ISet<V>,V>, Iterable<V>, Predicate<V>

All Known Subinterfaces:

IDiffSet<V>, IDiffSet.Durable<V>, IDiffSortedSet<V>, IDiffSortedSet.Durable<V>, ISet.Durable<V>, ISortedSet<V>

All Known Implementing Classes:

DiffSet, DiffSortedSet, IntSet, ISet.Mixin, ISortedSet.Mixin, LinearSet, Set, Slice.SortedSet, SortedSet
```
public interface ISet<V>
extends ICollection<ISet<V>,V>, Predicate<V>
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static interface ISet.Durable<V>

static class ISet.Mixin<V>

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`ISet.Durable<V>`
`static class`	`ISet.Mixin<V>`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default ISet<V>`	`add(V value)`
`default boolean`	`contains(V value)`
`default boolean`	`containsAll(IMap<V,?> map)`
`default boolean`	`containsAll(ISet<V> set)`
`default boolean`	`containsAny(IMap<V,?> map)`
`default boolean`	`containsAny(ISet<V> set)`
`default IDiffSet<V>`	`diff()`
`default ISet<V>`	`difference(ISet<V> set)`
`default IList<V>`	`elements()`
`default ISet<V>`	`forked()` This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable.
`OptionalLong`	`indexOf(V element)`
`default ISet<V>`	`intersection(ISet<V> set)`
`default boolean`	`isLinear()`
`default Iterator<V>`	`iterator(long startIndex)`
`default ISet<V>`	`linear()` This returns a data structure which is linear, or temporarily mutable.
`default ISet<V>`	`remove(V value)`
`default ISet<V>`	`sliceIndices(long startIndex, long endIndex)`
`default IList<? extends ISet<V>>`	`split(int parts)` Splits the collection into roughly even pieces, for parallel processing.
`default Spliterator<V>`	`spliterator()`
`default Stream<V>`	`stream()`
`default boolean`	`test(V v)`
`default Object[]`	`toArray()`
`default V[]`	`toArray(IntFunction<V[]> allocator)`
`default Set<V>`	`toSet()`
`default ISet<V>`	`union(ISet<V> set)`
`BiPredicate<V,V>`	`valueEquality()`
`ToLongFunction<V>`	`valueHash()`
`default <U> IMap<V,U>`	`zip(Function<V,U> f)`

Methods inherited from interface io.lacuna.bifurcan.ICollection
clone, iterator, nth, nth, save, size

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface java.util.function.Predicate
and, isEqual, negate, or

- Method Detail
  - valueHash
```
ToLongFunction<V> valueHash()
```
    Returns:
    
    the hash function used by the set
  - valueEquality
```
BiPredicate<V,V> valueEquality()
```
    Returns:
    
    the equality semantics used by the set
  - contains
```
default boolean contains(V value)
```
    Returns:
    
    true, if the set contains value
  - elements
```
default IList<V> elements()
```
    Returns:
    
    a list containing all the elements in the set
  - zip
```
default <U> IMap<V,U> zip(Function<V,U> f)
```
    Returns:
    
    a map which has a corresponding value, computed by f, for each element in the set
  - indexOf
```
OptionalLong indexOf(V element)
```
    Returns:
    
    the position of element in the collection, if it's present
  - containsAll
```
default boolean containsAll(ISet<V> set)
```
    Returns:
    
    true if this set contains every element in set
  - containsAll
```
default boolean containsAll(IMap<V,?> map)
```
    Returns:
    
    true if this set contains every key in map
  - containsAny
```
default boolean containsAny(ISet<V> set)
```
    Returns:
    
    true if this set contains any element in set
  - containsAny
```
default boolean containsAny(IMap<V,?> map)
```
    Returns:
    
    true if this set contains any key in map
  - add
```
default ISet<V> add(V value)
```
    Returns:
    
    the set, containing value
  - remove
```
default ISet<V> remove(V value)
```
    Returns:
    
    the set, without value
  - iterator
```
default Iterator<V> iterator(long startIndex)
```
    Specified by:
    
    iterator in interface ICollection<ISet<V>,V>
    
    Returns:
    
    an iterator representing the elements of the set
  - spliterator
```
default Spliterator<V> spliterator()
```
    Specified by:
    
    spliterator in interface Iterable<V>
  - stream
```
default Stream<V> stream()
```
    Returns:
    
    a Stream, representing the elements in the set
  - union
```
default ISet<V> union(ISet<V> set)
```
    Returns:
    
    a new set, representing the union with set
  - difference
```
default ISet<V> difference(ISet<V> set)
```
    Returns:
    
    a new set, representing the difference with set
  - intersection
```
default ISet<V> intersection(ISet<V> set)
```
    Returns:
    
    a new set, representing the intersection with set
  - toSet
```
default Set<V> toSet()
```
    Returns:
    
    the collection, represented as a normal Java set, which will throw UnsupportedOperationException on writes
  - toArray
```
default Object[] toArray()
```
    Returns:
    
    the elements of the list, in an array
  - toArray
```
default V[] toArray(IntFunction<V[]> allocator)
```
    Parameters:
    
    allocator - a function which creates an array of the specified size
    
    Returns:
    
    the elements of the list, in a typed array
  - diff
```
default IDiffSet<V> diff()
```
    Returns:
    
    a diff wrapper around this collection
  - isLinear
```
default boolean isLinear()
```
    Specified by:
    
    isLinear in interface ICollection<ISet<V>,V>
    
    Returns:
    
    true, if the set is linear
  - forked
```
default ISet<V> forked()
```
    Description copied from interface: ICollection
    
    This returns a data structure which is forked, which is equivalent to Clojure's persistent data structures, also sometimes called functional or immutable. This is called "forked" because it means that multiple functions can make divergent changes to the data structure without affecting each other.
    If only a single function or scope uses the data structure, it can be left as a linear data structure, which can have significant performance benefits.
    If the data structure is already forked, it will simply return itself.
    
    Specified by:
    
    forked in interface ICollection<ISet<V>,V>
    
    Returns:
    
    a forked form of the data structure
  - linear
```
default ISet<V> linear()
```
    Description copied from interface: ICollection
    
    This returns a data structure which is linear, or temporarily mutable. The term "linear", as used here, does not completely align with the formal definition of linear types as used in type theory. It is meant to describe the linear dataflow of the method calls, and as a converse to "forked" data structures.
    If ICollection.forked() is called on a linear collection, all references to that linear collection should be discarded.
    If the data structure is already linear, it will simply return itself.
    
    Specified by:
    
    linear in interface ICollection<ISet<V>,V>
    
    Returns:
    
    a linear form of this data structure
  - sliceIndices
```
default ISet<V> sliceIndices(long startIndex,
                             long endIndex)
```
  - split
```
default IList<? extends ISet<V>> split(int parts)
```
    Description copied from interface: ICollection
    
    Splits the collection into roughly even pieces, for parallel processing. Depending on the size and contents of the collection, this function may not return exactly parts subsets.
    
    Specified by:
    
    split in interface ICollection<ISet<V>,V>
    
    Parameters:
    
    parts - the target number of pieces
    
    Returns:
    
    a list containing subsets of the collection.
  - test
```
default boolean test(V v)
```
    Specified by:
    
    test in interface Predicate<V>

Interface ISet<V>

Nested Class Summary

Method Summary

Methods inherited from interface io.lacuna.bifurcan.ICollection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface java.util.function.Predicate

Method Detail

valueHash

valueEquality

contains

elements

zip

indexOf

containsAll

containsAll

containsAny

containsAny

add

remove

iterator

spliterator

stream

union

difference

intersection

toSet

toArray

toArray

diff

isLinear

forked

linear

sliceIndices

split

test