> ## Documentation Index > Fetch the complete documentation index at: https://docs.canton.network/llms.txt > Use this file to discover all available pages before exploring further. # DA.List > Reference documentation for Daml module DA.List. # DA.List List ## Module Snapshot Stable. Status: `active` Introduced in: `3.4.9` Removed in: `-` Warnings: `0` Deprecations: `0` Deprecated since: `-` ## Functions ### `sort` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} sort : Ord a => [a] -> [a] ``` The `sort` function implements a stable sorting algorithm. It is a special case of `sortBy`, which allows the programmer to supply their own comparison function. Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input (a stable sort). ### `sortBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} sortBy : (a -> a -> Ordering) -> [a] -> [a] ``` The `sortBy` function is the non-overloaded version of `sort`. ### `minimumBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} minimumBy : (a -> a -> Ordering) -> [a] -> a ``` `minimumBy f xs` returns the first element `x` of `xs` for which `f x y` is either `LT` or `EQ` for all other `y` in `xs`. `xs` must be non-empty. ### `maximumBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} maximumBy : (a -> a -> Ordering) -> [a] -> a ``` `maximumBy f xs` returns the first element `x` of `xs` for which `f x y` is either `GT` or `EQ` for all other `y` in `xs`. `xs` must be non-empty. ### `sortOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} sortOn : Ord k => (a -> k) -> [a] -> [a] ``` Sort a list by comparing the results of a key function applied to each element. `sortOn f` is equivalent to `sortBy (comparing f)`, but has the performance advantage of only evaluating `f` once for each element in the input list. This is sometimes called the decorate-sort-undecorate paradigm. Elements are arranged from from lowest to highest, keeping duplicates in the order they appeared in the input. ### `minimumOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} minimumOn : Ord k => (a -> k) -> [a] -> a ``` `minimumOn f xs` returns the first element `x` of `xs` for which `f x` is smaller than or equal to any other `f y` for `y` in `xs`. `xs` must be non-empty. ### `maximumOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} maximumOn : Ord k => (a -> k) -> [a] -> a ``` `maximumOn f xs` returns the first element `x` of `xs` for which `f x` is greater than or equal to any other `f y` for `y` in `xs`. `xs` must be non-empty. ### `mergeBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} mergeBy : (a -> a -> Ordering) -> [a] -> [a] -> [a] ``` Merge two sorted lists using into a single, sorted whole, allowing the programmer to specify the comparison function. ### `combinePairs` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} combinePairs : (a -> a -> a) -> [a] -> [a] ``` Combine elements pairwise by means of a programmer supplied function from two list inputs into a single list. ### `foldBalanced1` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} foldBalanced1 : (a -> a -> a) -> [a] -> a ``` Fold a non-empty list in a balanced way. Balanced means that each element has approximately the same depth in the operator tree. Approximately the same depth means that the difference between maximum and minimum depth is at most 1. The accumulation operation must be associative and commutative in order to get the same result as `foldl1` or `foldr1`. ### `group` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} group : Eq a => [a] -> [[a]] ``` The 'group' function groups equal elements into sublists such that the concatenation of the result is equal to the argument. ### `groupBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} groupBy : (a -> a -> Bool) -> [a] -> [[a]] ``` The 'groupBy' function is the non-overloaded version of 'group'. ### `groupOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} groupOn : Eq k => (a -> k) -> [a] -> [[a]] ``` Similar to 'group', except that the equality is done on an extracted value. ### `dedup` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dedup : Ord a => [a] -> [a] ``` `dedup l` removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. It is a special case of `dedupBy`, which allows the programmer to supply their own equality test. `dedup` is called `nub` in Haskell. ### `dedupBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dedupBy : (a -> a -> Ordering) -> [a] -> [a] ``` A version of `dedup` with a custom predicate. ### `dedupOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dedupOn : Ord k => (a -> k) -> [a] -> [a] ``` A version of `dedup` where deduplication is done after applyng function. Example use: `dedupOn (.employeeNo) employees` ### `dedupSort` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dedupSort : Ord a => [a] -> [a] ``` The `dedupSort` function sorts and removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. ### `dedupSortBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dedupSortBy : (a -> a -> Ordering) -> [a] -> [a] ``` A version of `dedupSort` with a custom predicate. ### `unique` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} unique : Ord a => [a] -> Bool ``` Returns True if and only if there are no duplicate elements in the given list. ### `uniqueBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} uniqueBy : (a -> a -> Ordering) -> [a] -> Bool ``` A version of `unique` with a custom predicate. ### `uniqueOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} uniqueOn : Ord k => (a -> k) -> [a] -> Bool ``` Returns True if and only if there are no duplicate elements in the given list after applyng function. Example use: `assert $ uniqueOn (.employeeNo) employees` ### `replace` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} replace : Eq a => [a] -> [a] -> [a] -> [a] ``` Given a list and a replacement list, replaces each occurance of the search list with the replacement list in the operation list. ### `dropPrefix` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dropPrefix : Eq a => [a] -> [a] -> [a] ``` Drops the given prefix from a list. It returns the original sequence if the sequence doesn't start with the given prefix. ### `dropSuffix` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dropSuffix : Eq a => [a] -> [a] -> [a] ``` Drops the given suffix from a list. It returns the original sequence if the sequence doesn't end with the given suffix. ### `stripPrefix` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} stripPrefix : Eq a => [a] -> [a] -> Optional [a] ``` The `stripPrefix` function drops the given prefix from a list. It returns `None` if the list did not start with the prefix given, or `Some` the list after the prefix, if it does. ### `stripSuffix` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} stripSuffix : Eq a => [a] -> [a] -> Optional [a] ``` Return the prefix of the second list if its suffix matches the entire first list. ### `stripInfix` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} stripInfix : Eq a => [a] -> [a] -> Optional ([a], [a]) ``` Return the string before and after the search string or `None` if the search string is not found. ``` >>> stripInfix [0,0] [1,0,0,2,0,0,3] Some ([1], [2,0,0,3]) >>> stripInfix [0,0] [1,2,0,4,5] None ``` ### `isPrefixOf` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} isPrefixOf : Eq a => [a] -> [a] -> Bool ``` The `isPrefixOf` function takes two lists and returns `True` if and only if the first is a prefix of the second. ### `isSuffixOf` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} isSuffixOf : Eq a => [a] -> [a] -> Bool ``` The `isSuffixOf` function takes two lists and returns `True` if and only if the first list is a suffix of the second. ### `isInfixOf` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} isInfixOf : Eq a => [a] -> [a] -> Bool ``` The `isInfixOf` function takes two lists and returns `True` if and only if the first list is contained anywhere within the second. ### `mapAccumL` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} mapAccumL : (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) ``` The `mapAccumL` function combines the behaviours of `map` and `foldl`; it applies a function to each element of a list, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list. ### `mapWithIndex` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} mapWithIndex : (Int -> a -> b) -> [a] -> [b] ``` A generalisation of `map`, `mapWithIndex` takes a mapping function that also depends on the element's index, and applies it to every element in the sequence. ### `inits` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} inits : [a] -> [[a]] ``` The `inits` function returns all initial segments of the argument, shortest first. ### `intersperse` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} intersperse : a -> [a] -> [a] ``` The `intersperse` function takes an element and a list and "intersperses" that element between the elements of the list. ### `intercalate` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} intercalate : [a] -> [[a]] -> [a] ``` `intercalate` inserts the list `xs` in between the lists in `xss` and concatenates the result. ### `tails` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} tails : [a] -> [[a]] ``` The `tails` function returns all final segments of the argument, longest first. ### `dropWhileEnd` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} dropWhileEnd : (a -> Bool) -> [a] -> [a] ``` A version of `dropWhile` operating from the end. ### `takeWhileEnd` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} takeWhileEnd : (a -> Bool) -> [a] -> [a] ``` A version of `takeWhile` operating from the end. ### `transpose` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} transpose : [[a]] -> [[a]] ``` The `transpose` function transposes the rows and columns of its argument. ### `breakEnd` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} breakEnd : (a -> Bool) -> [a] -> ([a], [a]) ``` Break, but from the end. ### `breakOn` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} breakOn : Eq a => [a] -> [a] -> ([a], [a]) ``` Find the first instance of `needle` in `haystack`. The first element of the returned tuple is the prefix of `haystack` before `needle` is matched. The second is the remainder of `haystack`, starting with the match. If you want the remainder *without* the match, use `stripInfix`. ### `breakOnEnd` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} breakOnEnd : Eq a => [a] -> [a] -> ([a], [a]) ``` Similar to `breakOn`, but searches from the end of the string. The first element of the returned tuple is the prefix of `haystack` up to and including the last match of `needle`. The second is the remainder of `haystack`, following the match. ### `linesBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} linesBy : (a -> Bool) -> [a] -> [[a]] ``` A variant of `lines` with a custom test. In particular, if there is a trailing separator it will be discarded. ### `wordsBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} wordsBy : (a -> Bool) -> [a] -> [[a]] ``` A variant of `words` with a custom test. In particular, adjacent separators are discarded, as are leading or trailing separators. ### `head` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} head : [a] -> a ``` Extract the first element of a list, which must be non-empty. ### `tail` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} tail : [a] -> [a] ``` Extract the elements after the head of a list, which must be non-empty. ### `last` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} last : [a] -> a ``` Extract the last element of a list, which must be finite and non-empty. ### `init` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} init : [a] -> [a] ``` Return all the elements of a list except the last one. The list must be non-empty. ### `foldl1` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} foldl1 : (a -> a -> a) -> [a] -> a ``` Left associative fold of a list that must be non-empty. ### `foldr1` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} foldr1 : (a -> a -> a) -> [a] -> a ``` Right associative fold of a list that must be non-empty. ### `repeatedly` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} repeatedly : ([a] -> (b, [a])) -> [a] -> [b] ``` Apply some operation repeatedly, producing an element of output and the remainder of the list. ### `chunksOf` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} chunksOf : Int -> [a] -> [[a]] ``` Splits a list into chunks of length @n\@. @n@ must be strictly greater than zero. The last chunk will be shorter than @n@ in case the length of the input is not divisible by @n\@. ### `delete` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} delete : Eq a => a -> [a] -> [a] ``` `delete x` removes the first occurrence of `x` from its list argument. For example, ``` > delete "a" ["b","a","n","a","n","a"] ["b","n","a","n","a"] ``` It is a special case of 'deleteBy', which allows the programmer to supply their own equality test. ### `deleteBy` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} deleteBy : (a -> a -> Bool) -> a -> [a] -> [a] ``` The 'deleteBy' function behaves like 'delete', but takes a user-supplied equality predicate. ``` > deleteBy (<=) 4 [1..10] [1,2,3,5,6,7,8,9,10] ``` ### `\\` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} \\ : Eq a => [a] -> [a] -> [a] ``` The `\\` function is list difference (non-associative). In the result of `xs \\ ys`, the first occurrence of each element of `ys` in turn (if any) has been removed from `xs`. Thus ``` (xs ++ ys) \\ xs == ys ``` Note this function is *O(n\*m)* given lists of size *n* and *m*. ### `singleton` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} singleton : a -> [a] ``` Produce a singleton list. ``` >>> singleton True [True] ``` ### `!!` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} !! : [a] -> Int -> a ``` List index (subscript) operator, starting from 0. For example, `xs !! 2` returns the third element in `xs`. Raises an error if the index is not suitable for the given list. The function has complexity *O(n)* where *n* is the index given, unlike in languages such as Java where array indexing is *O(1)*. ### `elemIndex` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} elemIndex : Eq a => a -> [a] -> Optional Int ``` Find index of element in given list. Will return `None` if not found. ### `findIndex` ```haskell theme={"theme":{"light":"github-light","dark":"github-dark"}} findIndex : (a -> Bool) -> [a] -> Optional Int ``` Find index, given predicate, of first matching element. Will return `None` if not found.