MutSet

enum MutSet[t: Type, r: Eff]Source

case MutSet(Region[r], Ref[Set[t], r])

The Mutable Set type.

Definitions

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

Adds the element x to the mutable set s.

def addAll!(m: m[a], s: MutSet[a, r]): Unit \ r with Order[a], Foldable[m] 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 empty(rc: Region[r]): MutSet[a, r] \ r Source

Returns a fresh empty set.

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 with Monoid[b] 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 with Order[a] 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 with Order[a] 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 with ToString[a] 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 with Order[a] 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 partition(rc1: Region[r1], rc2: Region[r2], f: a -> Bool, s: MutSet[a, r]): (MutSet[a, r1], MutSet[a, r2]) \ r + r1 + r2 with Order[a]

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 with Order[a] 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 with Order[a] Source

Removes the element x from the mutable set s.

def removeAll!(m: m[a], s: MutSet[a, r]): Unit \ r with Order[a], Foldable[m] 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 with Order[a] 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 with Order[a], Foldable[m] 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 with Order[a] 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 with Order[a] 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 with Order[a] 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 with ToString[a] Source

Returns a string representation of the given mutable set s.

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

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