List

enum List[t: Type] with SendableSource

case Nilcase Cons(t, List[t])

The List type.

A list is either the empty list represented by Nil, or an element v followed by a list vs represented by v :: vs.

Definitions

def ap(f: List[a -> b \ ef], x: List[a]): List[b] \ ef Source

Apply every function from f to every argument from x and return a list with all results. For f = f1, f2, ... and x = x1, x2, ... the results appear in the order f1(x1), f1(x2), ..., f2(x1), f2(x2), ....

def append(l1: List[a], l2: List[a]): List[a] Source

Returns l2 appended to l1.

The infix operator ::: is an alias for append (l1 ::: l2 = append(l1, l2)).

def count(f: a -> Bool \ ef, l: List[a]): Int32 \ ef Source

Returns the number of elements in l that satisfy the predicate f.

def distinct(l: List[a]): List[a] with Eq[a] Source

Returns the list l with duplicates removed. The first occurence of an element is kept and except for the removal of subsequent duplicates the order of l is preserved.

distinct uses the Flix's builtin equality test. Use distinctWith if you need a custom equality test.

def distinctWith(f: a -> (a -> Bool), l: List[a]): List[a] Source

Returns the list l with duplicates removed using the supplied function f for comparison. The first occurrence of an element is kept and except for the removal of subsequent duplicates the order of l is preserved.

def drop(n: Int32, l: List[a]): List[a] Source

Returns l without the first n elements.

Returns Nil if n > length(l). Returns l if n < 0.

def dropWhile(f: a -> Bool \ ef, l: List[a]): List[a] \ ef Source

Returns l without the longest prefix that satisfies the predicate f.

def empty(_unit: Unit): List[a] Source

Returns the empty list Nil.

def enumerator(rc: Region[r], l: List[a]): Iterator[(Int32, a), r, r] \ r Source

Returns an iterator over l zipped with the indices of the elements.

def exists(f: a -> Bool \ ef, l: List[a]): Bool \ ef Source

Returns true if and only if at least one element in l satisfies the predicate f.

Returns false if l is empty.

def filter(f: a -> Bool \ ef, l: List[a]): List[a] \ ef Source

Returns a list of every element in l that satisfies the predicate f.

def filterMap(f: a -> Option[b] \ ef, l: List[a]): List[b] \ ef Source

Collects the results of applying the partial function f to every element in l.

def find(f: a -> Bool \ ef, l: List[a]): Option[a] \ ef Source

Alias for findLeft.

def findLeft(f: a -> Bool \ ef, l: List[a]): Option[a] \ ef Source

Optionally returns the first element of l that satisfies the predicate f when searching from left to right.

def findMap(f: a -> Option[b] \ ef, l: List[a]): Option[b] \ ef Source

Returns the first non-None result of applying the partial function f to each element of l.

Returns None if every element of l is None.

def findRight(f: a -> Bool \ ef, l: List[a]): Option[a] \ ef Source

Optionally returns the first element of l that satisfies the predicate f when searching from right to left.

def flatMap(f: a -> List[b] \ ef, l: List[a]): List[b] \ ef Source

Returns the result of applying f to every element in l and concatenating the results.

def flatten(l: List[List[a]]): List[a] Source

Returns the concatenation of the elements in l.

def fold(l: List[a]): a with Monoid[a] Source

Returns the result of applying combine to all the elements in l, using empty as the initial value.

def fold2(f: c -> (a -> (b -> c \ ef)), c: c, l1: List[a], l2: List[b]): c \ ef Source

Alias for foldLeft2.

def foldLeft(f: b -> (a -> b \ ef), s: b, l: List[a]): b \ ef Source

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

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

def foldLeft2(f: c -> (a -> (b -> c \ ef)), c: c, l1: List[a], l2: List[b]): c \ ef Source

Accumulates the result of applying f pairwise to the elements of l1 and l2 starting with the initial value c and going from left to right.

def foldMap(f: a -> b \ ef, l: List[a]): b \ ef with Monoid[b] Source

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

def foldRight(f: a -> (b -> b \ ef), s: b, l: List[a]): b \ ef Source

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

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

def foldRight2(f: a -> (b -> (c -> c \ ef)), c: c, l1: List[a], l2: List[b]): c \ ef Source

Accumulates the result of applying f pairwise to the elements of l1 and l2 starting with the initial value c and going from right to left.

def foldRightWithCont(f: a -> ((Unit -> b \ ef) -> b \ ef), z: b, l: List[a]): b \ ef Source

Applies f to a start value z and all elements in l 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, l: List[a]): Bool \ ef Source

Returns true if and only if all elements in l satisfy the predicate f.

Returns true if l is empty.

def forEach(f: a -> Unit \ ef, l: List[a]): Unit \ ef Source

Applies f to every element of l.

def forEachWithIndex(f: Int32 -> (a -> Unit \ ef), l: List[a]): Unit \ ef Source

Applies f to every element of l along with that element's index.

def frequency(l: List[t]): Map[t, Int32] with Order[t] Source

Returns the frequency for each element in list l

def groupBy(f: a -> (a -> Bool), l: List[a]): List[List[a]] Source

Partitions l into sublists such that for any two elements x and y in a sublist, f(x, y) is true.

A sublist is created by iterating through the remaining elements of l from left to right and adding an element to the sublist if and only if doing so creates no conflicts with the elements already in the sublist.

The function f must be pure.

def head(l: List[a]): Option[a] Source

Returns Some(x) if x is the first element of l.

Returns None if l is empty.

def indexOf(a: a, l: List[a]): Option[Int32] with Eq[a] Source

Optionally returns the position of x in l.

def init(l: List[a]): Option[List[a]] Source

Returns the sublist of l without the last element. Returns None if the list l is Nil.

def intercalate(l1: List[a], l2: List[List[a]]): List[a] Source

Returns the concatenation of the elements in l2 with the elements of l1 inserted between every two adjacent elements.

That is, returns y1 :: x1 ... xn :: y2 :: ... yn-1 :: x1 :: ... :: xn :: yn :: Nil.

def intersperse(a: a, l: List[a]): List[a] Source

Returns l with x inserted between every two adjacent elements.

def isEmpty(l: List[a]): Bool Source

Returns true if and only if l is the empty list, i.e. Nil.

def isInfixOf(l1: List[a], l2: List[a]): Bool with Eq[a] Source

Returns true if and only if l1 is an infix of l2.

def isPrefixOf(l1: List[a], l2: List[a]): Bool with Eq[a] Source

Returns true if and only if l1 is a prefix of l2.

def isSuffixOf(l1: List[a], l2: List[a]): Bool with Eq[a] Source

Returns true if and only if l1 is a suffix of l2.

def iterator(rc: Region[r], xs: List[a]): Iterator[a, r, r] \ r Source

Returns an iterator over l.

def join(sep: String, l: List[a]): String with ToString[a] Source

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

def joinWith(f: a -> String \ ef, sep: String, l: List[a]): String \ ef Source

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

def last(l: List[a]): Option[a] Source

Returns Some(x) if x is the last element of l.

Returns None if l is empty.

def length(l: List[a]): Int32 Source

Returns the length of l.

def map(f: a -> b \ ef, l: List[a]): List[b] \ ef Source

Returns the result of applying f to every element in l.

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

def map2(f: t1 -> (t2 -> r \ ef), l1: List[t1], l2: List[t2]): List[r] \ ef Source

Lift a binary function to work on lists of its original arguments, returning a list of applying all combinations of arguments. For argument lists l1 = x1, x2, ... and l2 = y1, y2, ... the results appear in the order f(x1,y1), f(x1,y2), ..., f(x2,y1), f(x2,y2), ....

def map3(f: t1 -> (t2 -> (t3 -> r \ ef)), l1: List[t1], l2: List[t2], l3: List[t3]): List[r] \ ef Source

Lift a ternary function to work on lists of its original arguments, returning a list of applying all combinations of arguments. For argument lists l1 = x1, x2, ..., l2 = y1, y2, ... and l3 = z1, z2, ... the results appear in the following order:

` f(x1,y1,z1), f(x1,y1,z2), ..., f(x1,y2,z1), f(x1,y2,z2), ..., f(x2,y1,z1), f(x2,y1,z2), ..., f(x2,y2,z1), f(x2,y2,z2), ...` ...`

def map4(f: t1 -> (t2 -> (t3 -> (t4 -> r \ ef))), l1: List[t1], l2: List[t2], l3: List[t3], l4: List[t4]): List[r] \ ef Source

Lift a 4-ary function to work on lists of its original arguments, returning a list of applying all combinations of arguments. The results appear in the order extending the pattern from map3.

def map5(f: t1 -> (t2 -> (t3 -> (t4 -> (t5 -> r \ ef)))), l1: List[t1], l2: List[t2], l3: List[t3], l4: List[t4], l5: List[t5]): List[r] \ ef

Source

Lift a 5-ary function to work on lists of its original arguments, returning a list of applying all combinations of arguments. The results appear in the order extending the pattern from map3.

def mapWithIndex(f: Int32 -> (a -> b \ ef), l: List[a]): List[b] \ ef Source

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

That is, the result is of the form: f(x1, 0) :: f(x2, 1) :: ....

def maximum(l: List[a]): Option[a] with Order[a] Source

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

Returns None if l is empty.

def maximumBy(cmp: a -> (a -> Comparison), l: List[a]): Option[a] Source

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

Returns None if l is empty.

def memberOf(a: a, l: List[a]): Bool with Eq[a] Source

Returns true if and only if l contains the element x.

def merge(l1: List[a], l2: List[a]): List[a] with Order[a] Source

Merges the two lists l1 and l2. Assuming they are both sorted. If two elements compare EqualTo, then the element of l1 is first in the result.

def minimum(l: List[a]): Option[a] with Order[a] Source

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

Returns None if l is empty.

def minimumBy(cmp: a -> (a -> Comparison), l: List[a]): Option[a] Source

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

Returns None if l is empty.

def partition(f: a -> Bool \ ef, l: List[a]): (List[a], List[a]) \ ef Source

Returns a pair of lists (l1, l2).

l1 contains all elements of l that satisfy the predicate f. l2 contains all elements of l that do not satisfy the predicate f.

def patch(i: Int32, n: Int32, l1: List[a], l2: List[a]): List[a] Source

Returns l2 with the n elements starting at index i replaced with the elements of l1.

If any of the indices i, i+1, i+2, ... , i+n-1 are out of range in l2 then no patching is done at these indices. If l1 becomes depleted then no further patching is done. If patching occurs at index i+j in l2, then the element at index j in l1 is used.

def permutations(l: List[a]): List[List[a]] Source

Returns all permutations of l in lexicographical order by element indices in l.

That is, l is the first permutation and reverse(l) is the last permutation.

def point(a: a): List[a] Source

Return the singleton list with element x.

def range(b: Int32, e: Int32): List[Int32] Source

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

Returns Nil if b >= e.

def reduceLeft(f: a -> (a -> a \ ef), l: List[a]): Option[a] \ ef Source

Applies f to all elements in l 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 l is empty.

def reduceRight(f: a -> (a -> a \ ef), l: List[a]): Option[a] \ ef Source

Applies f to all elements in l 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 l is empty.

def repeat(n: Int32, a: a): List[a] Source

Returns a list with the element x repeated n times.

Returns Nil if n < 0.

def replace(src: { src = a }, dst: { dst = a }, l: List[a]): List[a] with Eq[a] Source

Returns l with every occurrence of src replaced by dst.

def reverse(l: List[a]): List[a] Source

Returns the reverse of l.

def rotateLeft(n: Int32, l: List[a]): List[a] Source

Returns l with its elements rotated n positions to the left.

That is, returns a new list where the first n mod length(l) elements in l are the last n mod length(l) elements of the new list.

def rotateRight(n: Int32, l: List[a]): List[a] Source

Returns l with its elements rotated n positions to the right.

That is, returns a new list where the last n mod length(l) elements in l are the first n mod length(l) elements of the new list.

def scan(f: b -> (a -> b \ ef), s: b, l: List[a]): List[b] \ ef Source

Alias for scanLeft.

def scanLeft(f: b -> (a -> b \ ef), s: b, l: List[a]): List[b] \ ef Source

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

That is, the result is of the form: s :: f(s, x1) :: f(f(s, x1), x2) ....

def scanRight(f: a -> (b -> b \ ef), s: b, l: List[a]): List[b] \ ef Source

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

That is, the result is of the form: ... f(xn-1, f(xn, s)) :: f(xn, s) :: s.

def sequence(l: List[m[a]]): m[List[a]] with Applicative[m] Source

Returns the result of running all the actions in the list l going from left to right.

def shuffle(rnd: Random, l: List[a]): List[a] \ IO Source

Shuffles l using the Fisher–Yates shuffle.

def slice(start: { start = Int32 }, end: { end = Int32 }, l: List[a]): List[a] Source

Returns the sublist of l from index start (inclusive) to index end (exclusive).

That is, an element at index i in l is part of the returned sublist if and only if i >= start and i < end. Note: Indices that are out of bounds in l are not considered (i.e. slice(start, end, l) = slice(max(0, start), min(length(l), end), l)).

def sort(l: List[a]): List[a] with Order[a] Source

Sort list l so that 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 l.

The sort implementation is a Quicksort.

def sortBy(f: a -> b, l: List[a]): List[a] with Order[b] Source

Sort list l 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 sort is not stable, i.e., equal elements may appear in a different order than in the input l.

The sort implementation is a Quicksort.

def sortWith(cmp: a -> (a -> Comparison), l: List[a]): List[a] Source

Sort list l so that 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 l.

The sort implementation is a Quicksort.

def span(f: a -> Bool, l: List[a]): (List[a], List[a]) Source

Returns a pair of lists (l1, l2).

l1 is the longest prefix of l that satisfies the predicate f. l2 is the remainder of l.

The function f must be pure.

def splitAt(n: Int32, xs: List[a]): (List[a], List[a]) Source

Split the list xs at the position n returning the left and right parts. Position n is included in the right part.

Example: splitAt(2, 1::2::3::4::Nil) returns (1::2::Nil, 3::4::Nil)

Returns (xs, Nil) if n > length(xs). Returns (Nil, xs) if n < 0.

def subsequences(l: List[a]): List[List[a]] Source

Returns all subsequences of l in lexicographical order by element indices in l.

That is, l is the first subsequence and Nil is the last subsequence.

def sum(l: List[Int32]): Int32 Source

Returns the sum of all elements in the list l.

def sumWith(f: a -> Int32 \ ef, l: List[a]): Int32 \ ef Source

Returns the sum of all elements in the list l according to the function f.

def take(n: Int32, l: List[a]): List[a] Source

Returns the first n elements of l.

Returns l if n > length(l). Returns Nil if n < 0.

def takeWhile(f: a -> Bool \ ef, l: List[a]): List[a] \ ef Source

Returns the longest prefix of l that satisfies the predicate f.

def toArray(rc: Region[r], l: List[a]): Array[a, r] \ r Source

Returns the list l as an array.

def toChain(l: List[a]): Chain[a] Source

Returns the list l as a chain.

@Lazy

def toDelayList(l: List[a]): DelayList[a] Source

Returns the elements of l as a DelayList.

def toDelayMap(l: List[(a, b)]): DelayMap[a, b] with Order[a] Source

Returns the association list l as a DelayMap.

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

def toMap(l: List[(a, b)]): Map[a, b] with Order[a] Source

Returns the association list l as a map.

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

def toMapWith(f: a -> b, l: List[a]): Map[a, b] with Order[a] Source

Returns a map with elements of s as keys and f applied as values.

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

def toMutDeque(rc: Region[r], l: List[a]): MutDeque[a, r] \ r Source

Returns l as a MutDeque.

def toMutList(rc: Region[r], l: List[a]): MutList[a, r] \ r Source

Returns l as a mutable list.

def toNec(l: List[a]): Option[Nec[a]] Source

Returns the list l as Option[Nec[a]].

If l is empty return None, otherwise return the Nec wrapped in Some.

def toNel(l: List[a]): Option[Nel[a]] Source

Returns the list l as Option[Nel[a]].

If l is empty return None, otherwise return the Nel wrapped in Some.

def toSet(l: List[a]): Set[a] with Order[a] Source

Returns the list l as a set.

def toString(l: List[a]): String with ToString[a] Source

Renders the list l to a String.

def toVector(l: List[a]): Vector[a] Source

Returns the list l as a vector.

def transpose(l: List[List[a]]): List[List[a]] Source

Returns the transpose of l.

Returns l if the dimensions of the elements of l are mismatched.

def traverse(f: a -> m[b] \ ef, l: List[a]): m[List[b]] \ ef with Applicative[m] Source

Returns the result of applying the applicative mapping function f to all the elements of the list l going from left to right.

def unfold(f: s -> Option[(a, s)] \ ef, st: s): List[a] \ ef Source

Build a list by applying f to the seed value st.

f should return Some(a,st1) to signal a new list element a and a new seed value st1.

f should return None to signal the end of building the list.

def unfoldWithIter(next: Unit -> Option[a] \ ef): List[a] \ ef Source

Build a list by applying the function next to (). next is expected to encapsulate a stateful resource such as a file handle that can be iterated.

next should return Some(a) to signal a new list element a.

next should return None to signal the end of building the list.

def unfoldWithOkIter(next: Unit -> Result[e, Option[a]] \ ef): Result[e, List[a]] \ ef Source

Build a list by applying the function next to (). next is expected to encapsulate a stateful resource such as a file handle that can be iterated.

next should return Ok(Some(a) to signal a new list element Ok(a).

next should return Ok(None) to signal the end of building the list.

next should return Err(e) to signal that an error occurred. The function returns Err(e).

def unzip(l: List[(a, b)]): (List[a], List[b]) Source

Returns a pair of lists, the first containing all first components in l and the second containing all second components in l.

def unzip3(l: List[(a, b, c)]): (List[a], List[b], List[c]) Source

Returns a triple of lists, the first containing all first components in l the second containing all second components in l and the third containing all third components in l.

def update(i: Int32, a: a, l: List[a]): List[a] Source

Returns l with the element at index i replaced by x.

Returns l if i < 0 or i > length(l)-1.

def zip(l1: List[a], l2: List[b]): List[(a, b)] Source

Returns a list where the element at index i is (a, b) where a is the element at index i in l1 and b is the element at index i in l2.

If either l1 or l2 becomes depleted, then no further elements are added to the resulting list.

def zip3(l1: List[a], l2: List[b], l3: List[c]): List[(a, b, c)] Source

Returns a list where the element at index i is (a, b, c) where a is the element at index i in l1, b is the element at index i in l2 and c is the element at index i in l3.

If any one of l1, l2 or l3 become depleted, then no further elements are added to the resulting list.

def zipWith(f: a -> (b -> c \ ef), l1: List[a], l2: List[b]): List[c] \ ef Source

Returns a list where the element at index i is f(a, b) where a is the element at index i in l1 and b is the element at index i in l2.

If either l1 or l2 becomes depleted, then no further elements are added to the resulting list.

def zipWith3(f: a -> (b -> (c -> d \ ef)), l1: List[a], l2: List[b], l3: List[c]): List[d] \ ef Source

Returns a list where the element at index i is f(a, b, c) where a is the element at index i in l1, b is the element at index i in l2 and c is the element at index i in l3.

If any one of l1, l2 or l3 become depleted, then no further elements are added to the resulting list.

def zipWithA(f: a -> (b -> f[c] \ ef), xs: List[a], ys: List[b]): f[List[c]] \ ef with Applicative[f] Source

Generalize zipWith to an applicative functor f.

def zipWithIndex(l: List[a]): List[(Int32, a)] Source

Returns a list where each element e is mapped to (i, e) where i is the index of e.