Create a list of characters from lo to hi (including hi).

Concatenate all strings in a list.

Applies a function f to list of increasing elements from lo to hi (including both lo and hi ). If lo > hi the function returns the empty list.

Concatenate all strings in a list using a specific separator.

Return the head of list if the list is not empty.

Convert a maybestd/core/types/maybe: V -> V type to a list type.

Returns an integer list of increasing elements from lo to hi (including both lo and hi ). If lo > hi the function returns the empty list.

Returns an integer list of increasing elements from lo to hi with stride stride. If lo > hi the function returns the empty list.

Returns an integer list of increasing elements from lo to hi with stride stride. If lo > hi the function returns the empty list.

Apply a function f to each character in a string.

Append two lists.

Element-wise list equality.

Do all elements satisfy a predicate ?

Are there any elements in a list that satisfy a predicate ?

Append two lists.

Order on lists.

Concatenate all lists in a list (e.g. flatten the list). (tail-recursive).

Concatenate a list of maybestd/core/types/maybe: V -> V values.

Drop the first n elements of a list (or fewer if the list is shorter than n).

Drop all initial elements that satisfy predicate.

Retain only those elements of a list that satisfy the given predicate pred. For example: filterstd/core/list/filter: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e list<a>([1,2,3],odd?) == [1,3].

Retain only those elements of a list that satisfy the given predicate pred. For example: filterMap([1,2,3],fn(i) { if i.odd? then Nothingstd/core/types/Nothing: forall<a> maybe<a> else Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(i(*)std/core/int/(*): (int, int) -> inti) }) == [4].

Find the first element satisfying some predicate.

Find the first element satisfying some predicate and return it.

Concatenate the result lists from applying a function to all elements.

Concatenate the Juststd/core/types/Just: forall<a> (value : a) -> maybe<a> result elements from applying a function to all elements.

Fold a list from the left, i.e. foldlstd/core/list/foldl: forall<a,b,e> (xs : list<a>, z : b, f : (b, a) -> e b) -> e b([1,2],0,(+)) == (0+1)+2 Since foldlstd/core/list/foldl: forall<a,b,e> (xs : list<a>, z : b, f : (b, a) -> e b) -> e b is tail recursive, it is preferred over foldrstd/core/list/foldr: forall<a,b,e> (xs : list<a>, z : b, f : (a, b) -> e b) -> e b when using an associative function f.

Fold a list from the right, i.e. foldrstd/core/list/foldr: forall<a,b,e> (xs : list<a>, z : b, f : (a, b) -> e b) -> e b([1,2],0,(+)) == 1+(2+0) Note, foldrstd/core/list/foldr: forall<a,b,e> (xs : list<a>, z : b, f : (a, b) -> e b) -> e b is less efficient than foldlstd/core/list/foldl: forall<a,b,e> (xs : list<a>, z : b, f : (b, a) -> e b) -> e b as it reverses the list first.

Invoke action for each element of a list.

Invoke action for each element of a list, passing also the position of the element.

Invoke action for each element of a list while action return Nothingstd/core/types/Nothing: forall<a> maybe<a>.

Return the head of list with a default value in case the list is empty.

Returns the index of the first element where pred holds, or -1 if no such element exists.

Return the list without its last element. Return an empty list for an empty list.

Insert a separator sep between all elements of a list xs .

Is the list empty?

Append end to each string in the list xs and join them all together.
join-endstd/core/list/join-end: (xs : list<string>, end : string) -> string([],end) === ""
join-endstd/core/list/join-end: (xs : list<string>, end : string) -> string(["a","b"],"/") === "a/b/".

Return the last element of a list (or Nothingstd/core/types/Nothing: forall<a> maybe<a> for the empty list).

Returns the length of a list.

Split a string into a list of lines.

Lookup the first element satisfying some predicate.

Apply a function f to each element of the input list in sequence.

Apply a function f to each element of the input list in sequence where takes both the index of the current element and the element itself as arguments.

Apply a function f to each element of the input list in sequence where takes both the index of the current element, the element itself, and the tail list as arguments.

Apply a function f to each element of the input list in sequence where f takes both the current element and the tail list as arguments.

Invoke action on each element of a list while action returns Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>.

Returns the largest element of a list of integers (or defaultstd/core/exn/default: forall<a> (t : error<a>, def : a) -> a (=0) for the empty list).

Returns the smallest element of a list of integers (or defaultstd/core/exn/default: forall<a> (t : error<a>, def : a) -> a (=0) for the empty list).

Partition a list in two lists where the first list contains those elements that satisfy the given predicate pred. For example: partitionstd/core/list/partition: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e (list<a>, list<a>)([1,2,3],odd?) == ([1,3],[2]).

Remove those elements of a list that satisfy the given predicate pred. For example: removestd/core/list/remove: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e list<a>([1,2,3],odd?) == [2].

Create a list of n repeated elements x.

Reverse a list.

Efficiently reverse a list xs and append it to tl: reverse-appendstd/core/list/reverse-append: forall<a> (xs : list<a>, tl : list<a>) -> list<a>(xs,tl) == reversestd/core/list/reverse: forall<a> (xs : list<a>) -> list<a>(xs) ++ tl.

Concatenate all strings in a list in reverse order.

Show a list.

deprecated, use showstd/core/list/show: forall<a,e> (xs : list<a>, @implicit/show : (a) -> e string) -> e string instead.

Returns a singleton list.

Split a list at position n.

Return the sum of a list of integers.

Return the tail of list. Returns the empty list if xs is empty.

Take the first n elements of a list (or fewer if the list is shorter than n).

Keep only those initial elements that satisfy predicate.

Join a list of strings with newlines.

Unzip a list of pairs into two lists.

Unzip a list of triples into three lists.

Unzip a list of quadruples into four lists.

Zip two lists together by pairing the corresponding elements. The returned list is only as long as the smallest input list.

Zip two lists together by apply a function f to all corresponding elements. The returned list is only as long as the smallest input list.

Zip two lists together by apply a function f to all corresponding elements and their index in the list. The returned list is only as long as the smallest input list.