MutList

enum MutList[a: Type, r: Eff]Source

case MutList(Region[r], Ref[Array[a, r], r], Ref[Int32, r])

Represents a mutable list.

Invariant - The length is always higher than the total capacity of the array. - The capacity of the array is always 8 or more.

Definitions

def append!(m: m[a], v: MutList[a, r]): Unit \ r 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 empty mutable list with a 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 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 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 with Foldable[m] Source

Appends m to v i.e. inserts all elements from m into the end of 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!(from: { from = a }, to: { to = a }, v: MutList[a, r]): Unit \ r with Eq[a] Source

Replaces all occurrences of the from with to 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], rnd: Random, v: MutList[a, r1]): MutList[a, r1] \ r1 + IO Source

Shuffles v using the Fisher–Yates shuffle.

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

Returns a sorted copy of MutList v, where the elements are ordered from low to high according to their Order instance.

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 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(rc1: Region[r1], f: a -> b, v: MutList[a, r]): MutList[a, r1] \ r + r1 with Order[b] Source

Returns a sorted copy of MutList v, where the elements are ordered from low to high according to the Order instance for the values obtained by applying f to each element.

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(rc1: Region[r1], cmp: a -> (a -> Comparison), v: MutList[a, r]): MutList[a, r1] \ r + r1 Source

Returns a sorted copy of MutList v, where the elements are ordered from low to high according to the comparison function cmp.

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.