Computes the difference of this set and another set.

The empty set of the same type as this set

Creates a new set of this kind from an array of longs

The number of words (each with 64 bits) making up the set

The words at index idx, or 0L if outside the range of the set Note: requires idx >= 0

Alias for intersect

Alias for diff

Alias for concat

Alias for concat

Alias for prependAll

Tests if some element is contained in this set.

This method is equivalent to contains. It allows sets to be interpreted as predicates.

The class name of this collection. To be used for converting to string. Collections generally print like this:

<className>(elem_1, ..., elem_n)

Creates a new $coll by adding all elements contained in another collection to this $coll, omitting duplicates.

This method takes a collection of elements and adds all elements, omitting duplicates, into $coll.

Example:

scala> val a = Set(1, 2) concat Set(2, 3)
a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

Returns a new $coll containing the elements from the left hand operand followed by the elements from the right hand operand. The element type of the $coll is the most specific superclass encompassing the element types of the two operands.

Copy all elements of this collection to array xs, starting at start.

Counts the number of elements in the $coll which satisfy a predicate.

The rest of the collection without its n first elements. For linear, immutable collections this should avoid making a copy.

The rest of the collection without its n last elements. For linear, immutable collections this should avoid making a copy.

Skips longest sequence of elements of this iterator which satisfy given predicate p, and returns an iterator of the remaining elements.

Tests whether a predicate holds for at least one element of this $coll.

$mayNotTerminateInf

Selects all elements of this $coll which satisfy a predicate.

Selects all elements of this $coll which do not satisfy a predicate.

Finds the first element of the $coll satisfying a predicate, if any.

$mayNotTerminateInf $orderDependent

Returns the first key of the collection.

Flatmap

Flatmap

Fold left

Fold right

Tests whether a predicate holds for all elements of this $coll.

$mayNotTerminateInf

Apply f to each element for its side effects Note: [U] parameter needed to help scalac's type inference.

Partitions this $coll into a map of ${coll}s according to some discriminator function.

Note: When applied to a view or a lazy collection it will always force the elements.

Partitions elements in fixed size ${coll}s.

The first element of the collection.

The initial part of the collection without its last element.

Computes the intersection between this set and another set.

Is the collection empty?

Creates an iterator over all the keys(or elements) contained in this collection greater than or equal to start according to the ordering of this collection. x.keysIteratorFrom(y) is equivalent to but often more efficient than x.from(y).keysIterator.

The number of elements in this collection, if it can be cheaply computed, -1 otherwise. Cheaply usually means: Not requiring a collection traversal.

Selects the last element. $orderDependent

Returns the last key of the collection.

Optionally selects the last element. $orderDependent

Builds a new bitset by applying a function to all elements of this bitset

Map

Builds a new collection by applying a function to all elements of this $coll.

Finds the largest element.

Finds the first element which yields the largest value measured by function f.

Finds the smallest element.

Finds the first element which yields the smallest value measured by function f.

A string showing all elements of this collection, separated by string sep.

Is the collection not empty?

A pair of, first, all elements that satisfy prediacte p and, second, all elements that do not. Interesting because it splits a collection in two.

The default implementation provided here needs to traverse the collection twice. Strict collections have an overridden version of partition in Buildable, which requires only a single traversal.

As with ++, returns a new collection containing the elements from the left operand followed by the elements from the right operand.

It differs from ++ in that the right operand determines the type of the resulting collection rather than the left one. Mnemonic: the COLon is on the side of the new COLlection type.

Example:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = Vector(2)
y: scala.collection.immutable.Vector[Int] = Vector(2)

scala> val z = x ++: y
z: scala.collection.immutable.Vector[Int] = Vector(1, 2)

Multiplies up the elements of this collection.

Creates a ranged projection of this collection with both a lower-bound and an upper-bound.

Creates a ranged projection of this collection. Any mutations in the ranged projection will update this collection and vice versa.

Note: keys are not guaranteed to be consistent between this collection and the projection. This is the case for buffers where indexing is relative to the projection.

Reduces the elements of this $coll using the specified associative binary operator.

$undefinedorder

Applies a binary operator to all elements of this $coll, going left to right. $willNotTerminateInf $orderDependentFold

Optionally applies a binary operator to all elements of this $coll, going left to right. $willNotTerminateInf $orderDependentFold

Reduces the elements of this $coll, if any, using the specified associative binary operator.

$undefinedorder

Applies a binary operator to all elements of this $coll, going right to left. $willNotTerminateInf $orderDependentFold

Optionally applies a binary operator to all elements of this $coll, going right to left. $willNotTerminateInf $orderDependentFold

Computes a prefix scan of the elements of the collection.

Note: The neutral element z may be applied more than once.

Produces a collection containing cumulative results of applying the operator going left to right.

$willNotTerminateInf $orderDependent

Produces a collection containing cumulative results of applying the operator going right to left. The head of the collection is the last cumulative result. $willNotTerminateInf $orderDependent

Example:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

The number of elements in this collection. Does not terminate for infinite collections.

Selects an interval of elements. The returned collection is made up of all elements x which satisfy the invariant:

from <= indexOf(x) < until

$orderDependent

Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)

Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.) The "sliding window" step is set to one.

Splits this $coll into a prefix/suffix pair according to a predicate.

Note: c span p is equivalent to (but possibly more efficient than) (c takeWhile p, c dropWhile p), provided the evaluation of the predicate p does not cause any side-effects. $orderDependent

Splits this $coll into two at a given position. Note: c splitAt n is equivalent to (but possibly more efficient than) (c take n, c drop n). $orderDependent

Tests whether this set is a subset of another set.

An iterator over all subsets of this set.

An iterator over all subsets of this set of the given size. If the requested size is impossible, an empty iterator is returned.

Sums up the elements of this collection.

The rest of the collection without its first element.

A collection containing the first n elements of this collection.

A collection containing the last n elements of this collection.

Takes longest prefix of elements that satisfy a predicate. $orderDependent

Given a collection factory fi, convert this collection to the appropriate representation for the current element type A. Example uses:

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // for xs: Iterable[Int]

Convert collection to array.

Computes the union between of set and another set.

Converts this $coll of pairs into two collections of the first and second half of each pair.

val xs = $Coll(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == ($Coll(1, 2, 3),
//        $Coll(one, two, three))

A view representing the elements of this collection.

Creates a non-strict filter of this $coll.

Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations. $orderDependent

Computes the symmetric difference of this bitset and another bitset by performing a bitwise "exclusive-or".

Zip. Interesting because it requires to align to source collections.

Returns a $coll formed from this $coll and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.

Zips this $coll with its indices.

Alias for union