Canton developer docs / Application development

Complete documentation page mirrored and translated for learning. Attribution is shown at the bottom of each article.

阅读中文版

appdevreferencedaml-standard-libraryda-list

DA.List

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

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

sortBy : (a -> a -> Ordering) -> [a] -> [a]

The sortBy function is the non-overloaded version of sort.

minimumBy

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

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

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

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

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

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

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

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

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

groupBy : (a -> a -> Bool) -> [a] -> [[a]]

The ‘groupBy’ function is the non-overloaded version of ‘group’.

groupOn

groupOn : Eq k => (a -> k) -> [a] -> [[a]]

Similar to ‘group’, except that the equality is done on an extracted value.

dedup

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

dedupBy : (a -> a -> Ordering) -> [a] -> [a]

A version of dedup with a custom predicate.

dedupOn

dedupOn : Ord k => (a -> k) -> [a] -> [a]

A version of dedup where deduplication is done after applyng function. Example use: dedupOn (.employeeNo) employees

dedupSort

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

dedupSortBy : (a -> a -> Ordering) -> [a] -> [a]

A version of dedupSort with a custom predicate.

unique

unique : Ord a => [a] -> Bool

Returns True if and only if there are no duplicate elements in the given list.

uniqueBy

uniqueBy : (a -> a -> Ordering) -> [a] -> Bool

A version of unique with a custom predicate.

uniqueOn

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

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

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

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

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

stripSuffix : Eq a => [a] -> [a] -> Optional [a]

Return the prefix of the second list if its suffix matches the entire first list.

stripInfix

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

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

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

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

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

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

inits : [a] -> [[a]]

The inits function returns all initial segments of the argument, shortest first.

intersperse

intersperse : a -> [a] -> [a]

The intersperse function takes an element and a list and “intersperses” that element between the elements of the list.

intercalate

intercalate : [a] -> [[a]] -> [a]

intercalate inserts the list xs in between the lists in xss and concatenates the result.

tails

tails : [a] -> [[a]]

The tails function returns all final segments of the argument, longest first.

dropWhileEnd

dropWhileEnd : (a -> Bool) -> [a] -> [a]

A version of dropWhile operating from the end.

takeWhileEnd

takeWhileEnd : (a -> Bool) -> [a] -> [a]

A version of takeWhile operating from the end.

transpose

transpose : [[a]] -> [[a]]

The transpose function transposes the rows and columns of its argument.

breakEnd

breakEnd : (a -> Bool) -> [a] -> ([a], [a])

Break, but from the end.

breakOn

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

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

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

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 : [a] -> a

Extract the first element of a list, which must be non-empty.

tail

tail : [a] -> [a]

Extract the elements after the head of a list, which must be non-empty.

last

last : [a] -> a

Extract the last element of a list, which must be finite and non-empty.

init

init : [a] -> [a]

Return all the elements of a list except the last one. The list must be non-empty.

foldl1

foldl1 : (a -> a -> a) -> [a] -> a

Left associative fold of a list that must be non-empty.

foldr1

foldr1 : (a -> a -> a) -> [a] -> a

Right associative fold of a list that must be non-empty.

repeatedly

repeatedly : ([a] -> (b, [a])) -> [a] -> [b]

Apply some operation repeatedly, producing an element of output and the remainder of the list.

chunksOf

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

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

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]

\\

\\ : 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

singleton : a -> [a]

Produce a singleton list.

>>> singleton True
[True]

!!

!! : [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

elemIndex : Eq a => a -> [a] -> Optional Int

Find index of element in given list. Will return None if not found.

findIndex

findIndex : (a -> Bool) -> [a] -> Optional Int

Find index, given predicate, of first matching element. Will return None if not found.

Mirrored from Canton Network official documentation (CC-BY-4.0) by CC Privacy Club for learning purposes.