List

enum List[t: Type]Source

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.

Instances

instance Applicative[List]Source

instance Collectable[List[a]]Source

instance Eq[List[a]] with Eq[a]Source

instance Filterable[List]Source

instance Foldable[List]Source

instance ForEach[List[a]]Source

instance Formattable[List[a]] with Formattable[a]Source

instance FromJson[List[a]] with FromJson[a]Source

instance Functor[List]Source

instance Hash[List[a]] with Hash[a]Source

instance Iterable[List[a]]Source

instance Monad[List]Source

instance MonadZero[List]Source

instance MonadZip[List]Source

instance Monoid[List[a]]Source

instance Order[List[a]] with Order[a]Source

instance SemiGroup[List[a]]Source

instance ToFlix[List[a]]Source

instance ToJava[List[a]]Source

instance ToJson[List[a]] with ToJson[a]Source

instance ToString[List[a]] with ToString[a]Source

instance Traversable[List]Source

instance UnorderedFoldable[List]Source

instance Witherable[List]Source

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), ....

@Terminates

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)).

@Terminates

def cons(x: a, l: List[a]): List[a]§ Source

Returns a new list with element x added to the front of list l.

@Terminates

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

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

@Terminates

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

Returns the list l with duplicates removed. The first occurrence 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.

@Terminates

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.

@Terminates @Tailrec

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.

@Terminates @Tailrec

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

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

@Terminates

def empty(): List[a]§ Source

Returns the empty list Nil.

@Terminates @Tailrec

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.

@Terminates

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.

@Terminates

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.

@Terminates

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

Alias for findLeft.

@Terminates @Tailrec

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.

@Terminates @Tailrec

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.

@Terminates

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.

@Terminates

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

Alias for foldLeft2.

@Terminates @Tailrec

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).

@Terminates @Tailrec

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.

@Terminates

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.

@Terminates

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))...).

@Terminates

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.

@Terminates @Tailrec

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.

@Terminates @Tailrec

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

Applies f to every element of l.

@Terminates

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 get(i: Int32, l: List[a]): a§ Source

Returns the element at position i in the list l.

Throws IndexOutOfBoundsException if the index is out of bounds.

def groupBy(f: a -> b, l: List[a]): List[Nel[a]] with Eq[b]§ Source

Partitions l into sublists such that for any two elements x and y in a sublist, if f(x) and f(y) are equal according to Eq on b.

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.

def groupWith(f: a -> (a -> Bool), l: List[a]): List[Nel[a]]§ Source

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

The function f must be pure and define an equivalence relation.

@Terminates

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.

@Terminates

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

Optionally returns the position of x in l.

def indices(l: List[a]): Range[Int32]§ Source

Returns a range of all valid indices of the list l.

def indicesOf(x: a, l: List[a]): Vector[Int32] with Eq[a]§ Source

Returns the positions of all occurrences 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.

@Terminates

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

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

@Terminates @Tailrec

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.

@Terminates @Tailrec

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.

@Terminates

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 iterate(f: a -> Option[a] \ ef, x: a): List[a] \ ef§ Source

Build a list by applying f to the initial value x.

f should return Some(a1) to signal a new list element a1 (which also becomes the next input to f).

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

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.

@Terminates @Tailrec

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.

@Terminates

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

Returns the number of elements in l.

@Terminates

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.

@Terminates

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(0, x0) :: f(1, x1) :: ....

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.

@Terminates @Tailrec

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

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

@Terminates

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.

@Terminates

def nonEmpty(l: List[a]): Bool§ Source

Returns true if and only if l is a non-empty list.

@Terminates

def nth(i: Int32, l: List[a]): Option[a]§ Source

Optionally returns the element at position i in the list l.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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

Returns l without adjacent duplicates according to their Eq instance.

The first occurrence in a chain of duplicates is kept.

@Terminates

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

Returns l without adjacent duplicates according to the function f. Elements x and y are duplicates if and only if f(x, y) = true.

The first occurrence in a chain of duplicates is kept.

f must define an equivalence relation on the elements of the list.

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

Returns a list with the element x repeated n times.

Returns Nil if n < 0.

@Terminates

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.

@Terminates

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.

@Terminates

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

Alias for scanLeft.

@Terminates

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) ....

@Terminates

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(l: List[a]): List[a] \ Shuffle§ Source

Shuffles l using the Fisher–Yates shuffle.

@Terminates

def size(l: List[a]): Int32§ Source

Returns the number of elements in l.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

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 the last occurrence is kept.

def toMapWith(f: a -> (k, v) \ ef, l: List[a]): Map[k, v] \ ef with Order[k]§ Source

Returns a map with mappings k => v where (k, v) = f(x) for some x in l.

If multiple mappings with the same key are produced only the last occurrence is kept.

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).

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.

@Terminates

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.