Apply s to the Nil of a list.

Applies s1 to all elements in a list, except the last, wheres2 is applied.

Apply s to the last Cons ([_]) of a list.

Apply a strategy to some suffix of a list.

The longest suffix (that is, the first application in a list)is preferred.

Apply a strategy to some suffix of a list.

The shortest suffix (that is, the last application in a list)is preferred.

Apply a strategy to the tail of a list.

Splits a list in two, with the second part containing the lastn elements and and first part containing all elements except thelast n.

Returns the common prefix of two lists.

Examples:<common-prefix>([1,2,3], [1,2,4,5]) => [1,2]<common-prefix>([1,2,3], [2,3,4]) => []

Concatenates all lists of a tuple.

Concatenates a list of lists into one list.

Example: <concat> [[1,2],[3,4],[5,6]] => [1,2,3,4,5,6]

Makes n copies of a term into a list of duplicates, applyingthe strategy s to every copy. The first input term is the integer n, the second is the term to duplicate.

Example: <copy(\ "foo" -> "bar" \)> (3, "foo") => ["bar","bar,"bar"]

Drops the first n elements from a list. If the list hasfewer than n elements, the strategy fails.

Drops a number of terms from the front of a list.

The number is specified by the strategy argument, which shouldproduce an integer.

Drops elements from the start of a list until s succeeds. Thefirst element at which s succeeds and all following it will bereturned.

Example: <drop-until(?3)> [2,2,3,4] => [3,4]

Drops elements from the start of a list while s succeeds. Thefirst element at which s fails and all following it will bereturned.

Example: <drop-while(?2)> [2,2,3,4] => [3,4]

Succeeds if the term is in the list.

Succeeds if the term is in the list, using the givenstrategy for determining equality.

Eliminates all elements at the end of the two lists that are equal.Only works correctly on lists of equal length!

Example: <eliminate-common-suffix>([1,3,4], [1,2,4]) => ([1,3], [1,2])

Find first list element for which s succeeds.

Return first list element for which s succeeds.

Returns a list with the first and the last element ofthe input list. For the empty list and the singletonlist, this is equivalent to id.

Completely flattens a list and its sublists to a single list.

See list-misc-test for examples.

Left folds a list. That is, the strategy sis applied as a binary operator between all adjacent elements in the list.foldr starts by applying s to b and the first element inthe list. b is therefore the starting point of the folding.

Example: <foldl(add)> ([1,2,3,4], 0)

Right folds a list. That is, the strategy s2 is applied as a binary operator between all adjacent elements in the list.foldr starts by applying s2 to the last element in the listand the result of s1. s1 is therefore the starting point ofthe folding.

Example: <foldr(!0, add)> [1,2,3,4] => 10

Right folds a list. That is, the strategy s2 is applied as a binary operator between all adjacent elements in the list.foldr starts by applying s2 to the last element in the listand the result of s1. s1 is therefore the starting point ofthe folding.

The additional parameter strategy f is applied to each element justbefore each folding step.

Example: <foldr(!0, add, inc)> [1,2,3,4] => 14

Succeeds if the input term is a list.

Returns the last element of a list.

Fails if applied to the empty list.

Returns the length of a list.

Returns a list of combinations by choosing one element from every list, in every possible combination.

Examples:

$ <list-combinations> [[1, 2]][[1],[2]]

$ <list-combinations> [[1, 2], []][]

$ <list-combinations> [[1, 2], ["a", "b"]][[1,"a"],[2,"a"],[1,"b"],[2,"b"]]

$ <list-combinations> [][[]]

Iterative loop over a list applying s to each element.

Apply a strategy to some elements in a list. The elementsof the original list will be kept unchanged when the strategy s fails.

Breaks a list into multiple parts (tokens).

The term argument sep is a list of delimiters (elements that separatetokens from one another), which is used to split the listinto multiple tokens. The result is a list of lists, i.e. a listof tokens.

Breaks a list into multiple parts (tokens).

The strategy argument sep is used to split the list. Wherever itsucceeds, the original list is split, and the parts are returnedas a list of lists, i.e. a list of tokens.

Applies a strategy to a list in bottom up order. That is to say,the strategy s will be applied to successively longer excerptsof the list, starting from the end.

At the first invocation, s will be applied to the tail of the list,and is expected to return a new list. The last element of the listwill then be added in front of this result, and s is applied tothis. The recursion continues through all elements from last tofirst, each time on a longer list, hence "bottom up".

Example: <listbu(![9 | <id>])> [1,2,3,4] => [9,1,9,2,9,3,9,4,9]

Concats two elements if both elements are lists. Otherwise, constructsa Conc term.

Generic term construction is used to avoid infinite recursion: makeConcis used in the compilation of Conc itself.

Apply a strategy to each element of a list.

Transform the elements of a list into lists (map)and concatenate into a single list (concat).

Note: equivalent to map(s); concat

Transposes an n by m matrix. The matrix must be represented asa list of n elements, where each element is a list of length m.The element of the inner lists may be of any type.

Example: <matrix-transpose> [[1,2],[3,4]] => [[1,3],[2,4]]

Succeeds if the first input term is a member of the second.

Reverses a list.

Reverses a list and applies s to all the elements.

In reverse order, apply a strategy to each element of a list.

Trim elements from the end of a list

Removes the longest sublist from the end of a list, for whichall elements satisfy the strategy s.

Separates the elements of the list by the specified separator.The separate-by variant that uses a term argument is prefered.

Separates the elements of the list by the specified separator.The separate-by variant that uses a term argument is prefered.

Separates the elements of the list by the specified separator.

Splits the list in two sublists, containing elements from 0 ton and from n onwards.

Example: <split-at(|4)>[1,2,3,4,5,6,7,8,9] => ([1,2,3,4], [5,6,7,8,9])

Splits a list in two parts at the first point where s succeeds.

The element to which s was applied is not part of the result. split-fetchfails if s cannot be applied to any of the elements.

Examples:<split-fetch(\ 3 -> 6 \)> [1, 2, 3] => ([1,2], [])<split-fetch(\ 3 -> 6 \)> [2, 3, 4] => ([2], [4])<split-fetch(\ 3 -> 6 \)> [3, 4, 5] => ([], [4,5])not(<split-fetch(\ 3 -> 6 \)> [8, 7, 6])

Splits a list in two parts at the point where s succeeds, keeping theelement at which s succeeded.

Unlike split-fetch, this strategy keeps the dividing element as part ofthe result as the second element in the triple: (before, split, after)

split-fetch-keep fails if s cannot be applied to any of the elements.

Splits a list into a tuple of its init list and last element.

Example:<split-init-last> [1, 2, 3, 4] => ([1, 2, 3], 4)<split-init-last> [1] => ([], 1)

Splits a list after n elements and applies strategy s to thefirst sublist. The second sublist is left untouched. Disregarding side-effects, splitmap is equal to !(<take(|n); map(s)>, <drop(|n)>). If side-effects areconsidered, note that application of s happens whiletraversing and splitting.

Take the first n elements of a list, given by isn. Thestrategy argument isn must produce an integer, whichgives the length of the sublist to return. If there arenot enough elements, this strategy fails.

Returns the first n elements of a list, failsif list has fewer than n elements.

Take elements from the start of a list until s succeeds. Each element of the list is tested against s, starting atthe head of the list. For as long as s does not succeed, the elements are accumulated in a list, which is returned atthe instant s fails. The actual term returned by s isignored. If s never succeeds, the entire list is returned.

Example: <take-until(?2; !3)> [3,3,2,4] => [3,3]

Take elements from the start of a list while s succeeds.Each element of the list is tested against s, starting atthe head of the list. For as long as s succeeds, the elementsare accumulated in a list, which is returned as s fails, orthe end of the list is reached. The actual term returned bys is ignored.

Example: <take-while(?2 ; !3)> [2,2,3] => [2,2]

Returns the n first elements after s has been applied to them.With the exception of side effects, takemap(s|n) is equal totake(|n); map(s). The difference when considering side-effectsis that s is applied while taking elements, so if s has aside-effect these will be performed, even if take fails.

Trim elements from both start and end of a list.

Removest the longest sublist from both start and end of alist for which all elements satisfy s.

Makes a Cons out of a tuple with head and tail. Thetail must be a list, but may be the empty list.

Splits a Cons into a tuple with head and tail.

Applies s to each element in the list, keeping along a separatecontext term.

For each element in the list, a tuple (a, b) is constructed andgiven to s. From the result, (a', b'), a' goes to the final listreturned by this strategy, and b' becomes the new b as s isapplied to the next element.

Example: <thread-map(add ; !(<id>, <id>))> ([1,2,3,4], 1) => ([2,4,7,11],11)