MutList

Definitions

def append(m: m[a], v: MutList[a, r]): Unit \ r + Aef[m] with Foldable[m] Source

Appends m to v i.e. inserts all elements from m into the end of v.

def clear(v: MutList[a, r]): Unit \ r Source

Removes all elements from the given mutable list v.

def compress(v: MutList[a, r]): Unit \ r Source

Compresses the given mutable list v if needed.

The mutable list will be shrunk to 1/2 of its size if the load factor is less than 1/4.

def copy(rc1: Region[r1], v: MutList[a, r]): MutList[a, r1] \ r + r1 Source

Returns a shallow copy of the given mutable list v. The capacity of the copy is equal to the length of the list.

def count(f: a -> Bool \ ef, v: MutList[a, r]): Int32 \ ef + r Source

Returns the number of elements in the given mutable list v that satisfies the given predicate f.

Returns 0 if the given mutable list v is empty.

def empty(rc: Region[r]): MutList[a, r] \ r Source

Returns an empty mutable list with a default capacity.

def emptyWithCapacity(rc: Region[r], capacity: Int32): MutList[a, r] \ r Source

Returns an empty mutable list with the given capacity rounded up to the default capacity.

def exists(f: a -> Bool \ ef, v: MutList[a, r]): Bool \ ef + r Source

Returns true if the given predicate f holds for at least one element of the given mutable list v.

Returns false if the given mutable list v is empty.

def find(f: a -> Bool, v: MutList[a, r]): Option[a] \ r Source

Alias for findLeft.

def findLeft(f: a -> Bool, v: MutList[a, r]): Option[a] \ r Source

Optionally returns the left-most element in the given mutable list v that satisfies the given predicate f.

Returns None if no element satisfies the given predicate f. Returns None if the given mutable list v is empty.

def findRight(f: a -> Bool, v: MutList[a, r]): Option[a] \ r Source

Optionally returns the right-most element in the given mutable list v that satisfies the given predicate f.

Returns None if no element satisfies the given predicate f. Returns None if the given mutable list v is empty.

def flatMap(rc1: Region[r1], f: a -> MutList[b, r1] \ ef, v: MutList[a, r]): MutList[b, r1] \ ef + r + r1 Source

Apply f to every element in v and concatenate the results.

The result is a new mutable list.

def flatten(rc1: Region[r1], v: MutList[MutList[a, r], r]): MutList[a, r1] \ r + r1 Source

Concatenates all the contained MutLists.

def foldLeft(f: b -> (a -> b \ ef), s: b, v: MutList[a, r]): b \ ef + r Source

Applies f to a start value s and all elements in a going from left to right.

That is, the result is of the form: f(...f(f(s, a[0]), a[1])..., xn).

def foldMap(f: a -> b \ ef, v: MutList[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), s: b, v: MutList[a, r]): b \ ef + r Source

Applies f to a start value s and all elements in a going from left to right.

That is, the result is of the form: f(...f(f(s, a[0]), a[1])..., xn).

The implementation is tail recursive.

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

Applies f to a start value z and all elements in a going from left to right.

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, v: MutList[a, r]): Bool \ ef + r Source

Returns true if the given predicate f holds for all elements of the given mutable list v.

Returns true if the given mutable list v is empty.

def forEach(f: a -> Unit \ ef, v: MutList[a, r]): Unit \ ef + r Source

Applies f to all the elements in v.

def forEachWithIndex(f: Int32 -> (a -> Unit \ ef), v: MutList[a, r]): Unit \ ef + r Source

Applies f to all the elements in v along with that element's index.

def get(i: Int32, v: MutList[a, r]): a \ r + OutOfBounds Source

Retrieves the value at position i in the mutable list v.

def head(v: MutList[a, r]): Option[a] \ r Source

Optionally returns the first element of the given mutable list v.

Returns None if the given mutable list v is empty.

def indexOf(x: a, v: MutList[a, r]): Option[Int32] \ r with Eq[a] Source

Alias for IndexOfLeft

def indexOfLeft(x: a, v: MutList[a, r]): Option[Int32] \ r with Eq[a] Source

Optionally returns the position of the first occurrence of x in v searching from left to right.

def indexOfRight(x: a, v: MutList[a, r]): Option[Int32] \ r with Eq[a] Source

Optionally returns the position of the first occurrence of x in v searching from right to left.

def insert(x: a, i: Int32, v: MutList[a, r]): Unit \ r Source

Inserts the given element x at the given position i in the given mutable list v.

Shifts elements as necessary. Possibly expensive operation.

If the given index i exceeds the length of the mutable list, the element is inserted at the last position.

def isEmpty(v: MutList[a, r]): Bool \ r Source

Returns true if the given mutable list v is empty.

def iterator(rc: Region[r1], l: MutList[a, r2]): Iterator[a, r1 + r2, r1] \ r1 + r2 Source

Returns an iterator over l.

Modifying l while using an iterator has undefined behavior and is dangerous.

def join(sep: String, v: MutList[a, r]): String \ r with ToString[a] Source

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

def joinWith(f: a -> String \ ef, sep: String, v: MutList[a, r]): String \ ef + r Source

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

def last(v: MutList[a, r]): Option[a] \ r Source

Optionally returns the last element of the given mutable list v.

Returns None if the given mutable list v is empty.

def length(v: MutList[a, r]): Int32 \ r Source

Returns the number of elements in the given mutable list v.

def map(rc1: Region[r1], f: a -> b \ ef, v: MutList[a, r]): MutList[b, r1] \ ef + r + r1 Source

Apply f to every element in v.

The result is an empty mutable list.

def mapWithIndex(rc1: Region[r1], f: Int32 -> (a -> b \ ef), v: MutList[a, r]): MutList[b, r1] \ ef + r + r1 Source

Returns the result of applying f to every element in v along with that element's index.

def maximum(v: MutList[a, r]): Option[a] \ r with Order[a] Source

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

Returns None if v is empty.

def maximumBy(cmp: a -> (a -> Comparison), v: MutList[a, r]): Option[a] \ r Source

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

Returns None if v is empty.

def memberOf(x: a, v: MutList[a, r]): Bool \ r with Eq[a] Source

Returns true if the given element x is a member of the given mutable list v.

def minimum(v: MutList[a, r]): Option[a] \ r with Order[a] Source

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

Returns None if v is empty.

def minimumBy(cmp: a -> (a -> Comparison), v: MutList[a, r]): Option[a] \ r Source

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

Returns None if v is empty.

def nonEmpty(v: MutList[a, r]): Bool \ r Source

Returns true if the given mutable list v is non-empty.

def nth(i: Int32, v: MutList[a, r]): Option[a] \ r Source

Optionally returns the element at position i in the mutable list v.

def pop(v: MutList[a, r]): Option[a] \ r Source

Optionally removes and returns the last element in the given mutable list v.

def push(x: a, v: MutList[a, r]): Unit \ r Source

Inserts the given element x at the end of the given mutable list v.

def pushAll(m: m[a], v: MutList[a, r]): Unit \ r + Aef[m] with Foldable[m] Source

Appends m to v i.e. inserts all elements from m into the end of v.

def put(x: a, i: Int32, v: MutList[a, r]): Unit \ r + OutOfBounds Source

Stores the value x at position i in the mutable list v.

def range(rc: Region[r], b: Int32, e: Int32): MutList[Int32, r] \ r Source

Returns a mutable list of all integers between b (inclusive) and e (exclusive).

Returns an empty mutable list if b >= e.

def reduceLeft(f: a -> (a -> a \ ef), v: MutList[a, r]): Option[a] \ ef + r Source

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

Returns None if v is empty.

def reduceRight(f: a -> (a -> a \ ef), v: MutList[a, r]): Option[a] \ ef + r Source

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

Returns None if v is empty.

def remove(i: Int32, v: MutList[a, r]): Unit \ r Source

Removes the element at the given position i in the given mutable list v.

Shifts elements as necessary. Possibly expensive operation.

If the given index i exceeds the length of the mutable list, no element is removed.

def replace(src: { src = a }, dst: { dst = a }, v: MutList[a, r]): Unit \ r with Eq[a] Source

Replaces all occurrences of the src with dst in the given mutable list v.

def reserve(n: Int32, v: MutList[a, r]): Unit \ r Source

Increases the capacity of the given mutable list v by at least n.

That is, after the call, the mutable list is guaranteed to have space for at least n additional elements.

The content of the mutable list is unchanged.

def retain(f: a -> Bool, v: MutList[a, r]): Unit \ r Source

Removes all elements from the given mutable list v that do not satisfy the given predicate f.

def reverse(v: MutList[a, r]): Unit \ r Source

Reverses the order of the elements in the given mutable list v.

def sameElements(v1: MutList[a, r1], v2: MutList[a, r2]): Bool \ r1 + r2 with Eq[a] Source

Returns true if the mutable lists v1 and v2 have the same elements in the same order, i.e. are structurally equal.

def scan(rc1: Region[r1], f: b -> (a -> b \ ef), s: b, v: MutList[a, r2]): MutList[b, r1] \ ef + r2 + r1 Source

Alias for scanLeft.

def scanLeft(rc1: Region[r1], f: b -> (a -> b \ ef), s: b, v: MutList[a, r2]): MutList[b, r1] \ ef + r2 + r1 Source

Accumulates the result of applying f to v going left to right.

def scanRight(rc1: Region[r1], f: a -> (b -> b \ ef), s: b, v: MutList[a, r2]): MutList[b, r1] \ ef + r2 + r1 Source

Accumulates the result of applying f to v going right to left.

def shrink(v: MutList[a, r]): Unit \ r Source

Shrinks the given mutable list v to its actual size.

def shuffle(rc1: Region[r1], v: MutList[a, r1]): MutList[a, r1] \ r1 + NonDet Source

Shuffles v using the Fisher–Yates shuffle.

def size(v: MutList[a, r]): Int32 \ r Source

Returns the number of elements in the given mutable list v.

def sort(v: MutList[a, r]): Unit \ r with Order[a] Source

Sort MutList v so that elements are ordered from low to high according to their Order instance. The MutList is mutated in-place.

The sort is not stable, i.e., equal elements may appear in a different order than in the input v.

The sort implementation is a Quicksort.

def sortBy(f: a -> b, v: MutList[a, r]): Unit \ r with Order[b] Source

Sort MutList v so that elements are ordered from low to high according to the Order instance for the values obtained by applying f to each element. The MutList is mutated in-place.

The sort is not stable, i.e., equal elements may appear in a different order than in the input v.

The sort implementation is a Quicksort.

def sortWith(cmp: a -> (a -> Comparison), v: MutList[a, r]): Unit \ r Source

Sort MutList v so that elements are ordered from low to high according to the comparison function cmp. The MutList is mutated in-place.

The sort is not stable, i.e., equal elements may appear in a different order than in the input v.

The sort implementation is a Quicksort.

def sum(v: MutList[Int32, r]): Int32 \ r Source

Returns the sum of all elements in the MutList v.

def sumWith(f: a -> Int32 \ ef, v: MutList[a, r]): Int32 \ ef + r Source

Returns the sum of all elements in the MutList v according to the function f.

def toArray(rc1: Region[r1], v: MutList[a, r2]): Array[a, r1] \ r2 + r1 Source

Returns v as an array.

def toChain(xs: MutList[a, r]): Chain[a] \ r Source

Returns the mutable list xs as a chain.

def toList(v: MutList[a, r]): List[a] \ r Source

Returns v as an immutable list.

def toMutDeque(rc1: Region[r1], v: MutList[a, r2]): MutDeque[a, r1] \ r2 + r1 Source

Returns v as a MutDeque.

def toString(l: MutList[a, r]): String \ r with ToString[a] Source

Returns a string representation of the given MutList l.

def toVector(xs: MutList[a, r]): Vector[a] \ r Source

Returns xs as a vector.

def transform(f: a -> a, v: MutList[a, r]): Unit \ r Source

Apply f to every element in v.

def transformWithIndex(f: Int32 -> (a -> a), v: MutList[a, r]): Unit \ r Source

Apply f to every element in v along with that element's index.

def truncate(l: Int32, v: MutList[a, r]): Unit \ r Source

Truncates the given mutable list v to the given length l.

That is, after the operation, the mutable list has length at most l.

If the given length l is negative, all elements are removed.