# MutSet

## Definitions

`def add!(x: a, s: MutSet[a, r]): Unit \ r`Source

Adds the element `x` to the mutable set `s`.

`def addAll!(m: m[a], s: MutSet[a, r]): Unit \ r`Source

Adds all elements in the collection `m` to the mutable set `s`.

`def clear!(s: MutSet[a, r]): Unit \ r`Source

Removes all elements from the mutable set `s`.

`def copy(rc1: Region[r1], s: MutSet[a, r]): MutSet[a, r1] \ r + r1`Source

Returns a shallow copy of the mutable set `s`.

`def count(f: a -> Bool \ ef, s: MutSet[a, r]): Int32 \ ef + r`Source

Returns the number of elements in the mutable set `s` that satisfy the predicate function `f`.

Purity reflective: Runs in parallel when given a pure function `f`.

`def enumerator(rc: Region[r1], s: MutSet[a, r2]): Iterator[(Int32, a), r1 + r2, r1] \ r1 + r2`Source

Returns an enumerator over `s`.

`def exists(f: a -> Bool \ ef, s: MutSet[a, r]): Bool \ ef + r`Source

Returns `true` if and only if at least one element in the mutable set `s` satisfies the predicate function `f`.

Returns `false` if `s` is the empty set.

`def find(f: a -> Bool, s: MutSet[a, r]): Option[a] \ r`Source

Alias for `findLeft`.

The function `f` must be pure.

`def findLeft(f: a -> Bool, s: MutSet[a, r]): Option[a] \ r`Source

Optionally returns the first element of the mutable set `s` that satisfies the predicate function `f` when searching from left to right.

The function `f` must be pure.

`def findRight(f: a -> Bool, s: MutSet[a, r]): Option[a] \ r`Source

Optionally returns the first element of the mutable set `s` that satisfies the predicate function `f` when searching from right to left.

The function `f` must be pure.

`def foldLeft(f: b -> (a -> b \ ef), i: b, s: MutSet[a, r]): b \ ef + r`Source

Applies `f` to a start value `i` and all elements in the mutable set `s` going from left to right.

That is, the result is of the form: `f(...f(f(i, x1), x2)..., xn)`.

`def foldMap(f: a -> b \ ef, s: MutSet[a, r]): b \ ef + r`Source

Returns the result of mapping each element and combining the results.

`def foldRight(f: a -> (b -> b \ ef), z: b, s: MutSet[a, r]): b \ ef + r`Source

Applies `f` to a start value `z` and all elements in the mutable set `s` going from right to left.

That is, the result is of the form: `f(x1, ...f(xn-1, f(xn, z))...)`.

`def foldRightWithCont(f: a -> ((Unit -> b \ ef) -> b \ ef), z: b, s: MutSet[a, r]): b \ ef + r`Source

Applies `f` to a start value `z` and all elements in the mutable set `s` going from right to left.

That is, the result is of the form: `f(x1, ...f(xn-1, f(xn, z))...)`. A `foldRightWithCont` allows early termination by not calling the continuation.

`def forAll(f: a -> Bool \ ef, s: MutSet[a, r]): Bool \ ef + r`Source

Returns `true` if and only if all elements in the mutable set `s` satisfy the predicate function `f`.

Returns `true` if `s` is the empty set.

`def forEach(f: a -> Unit \ ef, s: MutSet[a, r]): Unit \ ef + r`Source

Applies `f` to every element of the mutable set `s`.

`def forEachWithIndex(f: Int32 -> (a -> Unit \ ef), s: MutSet[a, r]): Unit \ ef + r`Source

Applies `f` to every element of the mutable set `s` along with that element's index.

`def isEmpty(s: MutSet[a, r]): Bool \ r`Source

Returns true if and only if `s` is the empty set.

`def isProperSubsetOf(s1: MutSet[a, r1], s2: MutSet[a, r2]): Bool \ r1 + r2`Source

Returns true if and only if every element in the mutable set `s1` appears in the mutable set `s2` and `s1 != s2`.

`def isSubsetOf(s1: MutSet[a, r1], s2: MutSet[a, r2]): Bool \ r1 + r2`Source

Returns true if and only if every element in the mutable set `s1` appears in the mutable set `s2`.

`def iterator(rc: Region[r1], s: MutSet[a, r2]): Iterator[a, r1 + r2, r1] \ r1 + r2`Source

Returns an iterator over `s`.

`def join(sep: String, s: MutSet[a, r]): String \ r`Source

Returns the concatenation of the string representation of each element in `s` with `sep` inserted between each element.

`def joinWith(f: a -> String \ ef, sep: String, s: MutSet[a, r]): String \ ef + r`Source

Returns the concatenation of the string representation of each element in `s` according to `f` with `sep` inserted between each element.

`def maximum(s: MutSet[a, r]): Option[a] \ r`Source

Optionally finds the largest element of `s` according to the `Order` on `a`.

Returns `None` if `s` is empty.

`def maximumBy(cmp: a -> (a -> Comparison \ ef), s: MutSet[a, r]): Option[a] \ ef + r`Source

Optionally finds the largest element of `s` according to the given comparator `cmp`.

Returns `None` if `s` is empty.

Purity reflective: Runs in parallel when given a pure function `f`.

`def memberOf(x: a, s: MutSet[a, r]): Bool \ r`Source

Returns true if and only if `x` is a member of the mutable set `s`.

`def minimum(s: MutSet[a, r]): Option[a] \ r`Source

Optionally finds the smallest element of `s` according to the `Order` on `a`.

Returns `None` if `s` is empty.

`def minimumBy(cmp: a -> (a -> Comparison \ ef), s: MutSet[a, r]): Option[a] \ ef + r`Source

Optionally finds the smallest element of `s` according to the given comparator `cmp`.

Returns `None` if `s` is empty.

Purity reflective: Runs in parallel when given a pure function `f`.

`def new(rc: Region[r]): MutSet[a, r] \ r`Source

Returns a fresh empty set.

`def partition(rc1: Region[r1], rc2: Region[r2], f: a -> Bool, s: MutSet[a, r]): (MutSet[a, r1], MutSet[a, r2]) \ r + r1 + r2`Source

`s1` contains all elements of the mutable set `s` that satisfy the predicate function `f`. `s2` contains all elements of the mutable set `s` that do not satisfy the predicate function `f`.

The function `f` must be pure.

`def reduceLeft(f: a -> (a -> a \ ef), s: MutSet[a, r]): Option[a] \ ef + r`Source

Applies `f` to all elements in the mutable set `s` going from left to right until a single value `v` is obtained. Returns `Some(v)`.

That is, the result is of the form: `Some(f(...f(f(x1, x2), x3)..., xn))`

Returns `None` if `s` is the empty set.

`def reduceRight(f: a -> (a -> a \ ef), s: MutSet[a, r]): Option[a] \ ef + r`Source

Applies `f` to all elements in the mutable set `s` going from right to left until a single value `v` is obtained. Returns `Some(v)`.

That is, the result is of the form: `Some(f(x1, ...f(xn-2, f(xn-1, xn))...))`

Returns `None` if `s` is the empty set.

`def refine!(f: a -> Bool, s: MutSet[a, r]): Unit \ r`Source

Removes all elements from the mutable set `s` that do not satisfy the predicate function `f`.

The function `f` must be pure.

`def remove!(x: a, s: MutSet[a, r]): Unit \ r`Source

Removes the element `x` from the mutable set `s`.

`def removeAll!(m: m[a], s: MutSet[a, r]): Unit \ r`Source

Removes all elements in the collection `m` from the mutable set `s`.

`def replace!(from: { from = a }, to: { to = a }, s: MutSet[a, r]): Unit \ r`Source

Replaces the element `from` with the element `to` if `from` is in the mutable set `s`.

The mutable set `s` is unchanged if the element `from` is not in it.

`def retainAll!(m: m[a], s: MutSet[a, r]): Unit \ r`Source

Removes all elements from the mutable set `s` that are not in collection `m`.

`def sameElements(a: MutSet[a, r], b: MutSet[a, r]): Bool \ r`Source

Returns `true` if MutSets `a` and `b` have the same elements, i.e. are structurally equal.

`def singleton(rc: Region[r], x: a): MutSet[a, r] \ r`Source

Returns the singleton set containing `x`.

`def size(s: MutSet[a, r]): Int32 \ r`Source

Returns the size of the mutable set `s`.

`def sum(s: MutSet[Int32, r]): Int32 \ r`Source

Returns the sum of all elements in the mutable set `s`.

`def sumWith(f: a -> Int32 \ ef, s: MutSet[a, r]): Int32 \ ef + r`Source

Returns the sum of all elements in the mutable set `s` according to the function `f`.

Purity reflective: Runs in parallel when given a pure function `f`.

`def toList(s: MutSet[a, r]): List[a] \ r`Source

Returns the mutable set `s` as a list.

`def toMap(s: MutSet[(a, b), r]): Map[a, b] \ r`Source

Returns the association set `s` as a map.

If `s` contains multiple mappings with the same key, `toMap` does not make any guarantees about which mapping will be in the resulting map.

`def toMutDeque(rc1: Region[r1], s: MutSet[a, r2]): MutDeque[a, r1] \ r2 + r1`Source

Returns the mutable set `s` as a MutDeque.

`def toSet(s: MutSet[a, r]): Set[a] \ r`Source

Returns the mutable set `s` as an immutable set.

`def toString(s: MutSet[a, r]): String \ r`Source

Returns a string representation of the given mutable set `s`.

`def transform!(f: a -> a \ ef, s: MutSet[a, r]): Unit \ ef + r`Source

Applies the function `f` to every element in the mutable set `s`.