protocol

# `listp`

List protocol.

Author: Paulo Moura
Version: 1.15
Date: 2019/1/3
Compilation flags:
`static`

(no dependencies on other entities)

## Public interface

### `append/2`

Appends all lists in a list of lists.

Compilation flags:
`static`
Template:
`append(Lists,Concatenation)`
Mode and number of proofs:
`append(+list(list),?list)` - `zero_or_one`

### `append/3`

Appends two lists.

Compilation flags:
`static`
Template:
`append(List1,List2,List)`
Mode and number of proofs:
`append(?list,?list,?list)` - `zero_or_more`

### `delete/3`

Deletes from a list all occurrences of an element returning the list of remaining elements. Uses ==/2 for element comparison.

Compilation flags:
`static`
Template:
`delete(List,Element,Remaining)`
Mode and number of proofs:
`delete(@list,@term,?list)` - `one`

### `delete_matches/3`

Deletes all matching elements from a list, returning the list of remaining elements. Uses =/2 for element comparison.

Compilation flags:
`static`
Template:
`delete_matches(List,Element,Remaining)`
Mode and number of proofs:
`delete_matches(@list,@term,?list)` - `one`

### `empty/1`

True if the argument is an empty list.

Compilation flags:
`static`
Template:
`empty(List)`
Mode and number of proofs:
`empty(@list)` - `zero_or_one`

### `flatten/2`

Flattens a list of lists into a list.

Compilation flags:
`static`
Template:
`flatten(List,Flatted)`
Mode and number of proofs:
`flatten(+list,-list)` - `one`

### `hamming_distance/3`

Calculates the Hamming distance between two lists (using equality to compare list elements). Fails if the two lists are not of the same length.

Compilation flags:
`static`
Template:
`hamming_distance(List1,List2,Distance)`
Mode and number of proofs:
`hamming_distance(+list,+list,-integer)` - `zero_or_one`

### `keysort/2`

Sorts a list of key-value pairs in ascending order.

Compilation flags:
`static`
Template:
`keysort(List,Sorted)`
Mode and number of proofs:
`keysort(+list(pair),-list(pair))` - `one`

### `last/2`

List last element (if it exists).

Compilation flags:
`static`
Template:
`last(List,Last)`
Mode and number of proofs:
`last(?list,?term)` - `zero_or_more`

### `length/2`

List length.

Compilation flags:
`static`
Template:
`length(List,Length)`
Mode and number of proofs:
`length(?list,?integer)` - `zero_or_more`

### `max/2`

Determines the list maximum value using standard order. Fails if the list is empty.

Compilation flags:
`static`
Template:
`max(List,Maximum)`
Mode and number of proofs:
`max(+list,-term)` - `zero_or_one`

### `member/2`

Element is a list member.

Compilation flags:
`static`
Template:
`member(Element,List)`
Mode and number of proofs:
`member(?term,?list)` - `zero_or_more`

### `memberchk/2`

Checks if a term is a member of a list.

Compilation flags:
`static`
Template:
`memberchk(Element,List)`
Mode and number of proofs:
`memberchk(?term,?list)` - `zero_or_one`

### `min/2`

Determines the minimum value in a list using standard order. Fails if the list is empty.

Compilation flags:
`static`
Template:
`min(List,Minimum)`
Mode and number of proofs:
`min(+list,-term)` - `zero_or_one`

### `msort/2`

Sorts a list in ascending order (duplicated elements are not removed).

Compilation flags:
`static`
Template:
`msort(List,Sorted)`
Mode and number of proofs:
`msort(+list,-list)` - `one`

### `msort/3`

Sorts a list using a user-specified comparison predicate modeled on the standard compare/3 predicate (duplicated elements are not removed).

Compilation flags:
`static`
Template:
`msort(Closure,List,Sorted)`
Meta-predicate template:
`msort(3,*,*)`
Mode and number of proofs:
`msort(+callable,+list,-list)` - `one`

### `nextto/3`

X and Y are consecutive elements in List.

Compilation flags:
`static`
Template:
`nextto(X,Y,List)`
Mode and number of proofs:
`nextto(?term,?term,?list)` - `zero_or_more`

### `nth0/3`

Nth element of a list (counting from zero).

Compilation flags:
`static`
Template:
`nth0(Nth,List,Element)`
Mode and number of proofs:
`nth0(?integer,?list,?term)` - `zero_or_more`

### `nth0/4`

Nth element of a list (counting from zero).

Compilation flags:
`static`
Template:
`nth0(Nth,List,Element,Residue)`
Mode and number of proofs:
`nth0(?integer,?list,?term,?list)` - `zero_or_more`

### `nth1/3`

Nth element of a list (counting from one).

Compilation flags:
`static`
Template:
`nth1(Nth,List,Element)`
Mode and number of proofs:
`nth1(?integer,?list,?term)` - `zero_or_more`

### `nth1/4`

Nth element of a list (counting from one).

Compilation flags:
`static`
Template:
`nth1(Nth,List,Element,Residue)`
Mode and number of proofs:
`nth1(?integer,?list,?term,?list)` - `zero_or_more`

### `partition/5`

Partitions a list in lists with values less, equal, and greater than a given value (using standard order).

Compilation flags:
`static`
Template:
`partition(List,Value,Less,Equal,Greater)`
Mode and number of proofs:
`partition(+list,+number,-list,-list,-list)` - `one`

### `permutation/2`

The two lists are a permutation of the same list.

Compilation flags:
`static`
Template:
`permutation(List,Permutation)`
Mode and number of proofs:
`permutation(?list,?list)` - `zero_or_more`

### `prefix/2`

Prefix is a prefix of List.

Compilation flags:
`static`
Template:
`prefix(Prefix,List)`
Mode and number of proofs:
`prefix(?list,+list)` - `zero_or_more`

### `prefix/3`

Prefix is a prefix of length Length of List.

Compilation flags:
`static`
Template:
`prefix(Prefix,Length,List)`
Mode and number of proofs:
`prefix(?list,+integer,+list)` - `zero_or_one`
`prefix(?list,-integer,+list)` - `zero_or_more`

### `proper_prefix/2`

Prefix is a proper prefix of List.

Compilation flags:
`static`
Template:
`proper_prefix(Prefix,List)`
Mode and number of proofs:
`proper_prefix(?list,+list)` - `zero_or_more`

### `proper_prefix/3`

Prefix is a proper prefix of length Length of List.

Compilation flags:
`static`
Template:
`proper_prefix(Prefix,Length,List)`
Mode and number of proofs:
`proper_prefix(?list,+integer,+list)` - `zero_or_one`
`proper_prefix(?list,-integer,+list)` - `zero_or_more`

### `remove_duplicates/2`

Removes duplicated list elements using equality (==/2) for comparison and keepying the left-most element when repeated.

Compilation flags:
`static`
Template:
`remove_duplicates(List,Set)`

### `reverse/2`

Reverses a list.

Compilation flags:
`static`
Template:
`reverse(List,Reversed)`
Mode and number of proofs:
`reverse(+list,-list)` - `one`
`reverse(+list,?list)` - `zero_or_one`
`reverse(?list,+list)` - `zero_or_one`
`reverse(-list,-list)` - `one_or_more`

### `same_length/2`

The two lists have the same length.

Compilation flags:
`static`
Template:
`same_length(List1,List2)`
Mode and number of proofs:
`same_length(+list,?list)` - `zero_or_one`
`same_length(?list,+list)` - `zero_or_one`
`same_length(-list,-list)` - `one_or_more`

### `same_length/3`

The two lists have the same length.

Compilation flags:
`static`
Template:
`same_length(List1,List2,Length)`
Mode and number of proofs:
`same_length(+list,?list,?integer)` - `zero_or_one`
`same_length(?list,+list,?integer)` - `zero_or_one`
`same_length(-list,-list,-integer)` - `one_or_more`

### `select/3`

Selects an element from a list, returning the list of remaining elements.

Compilation flags:
`static`
Template:
`select(Element,List,Remaining)`
Mode and number of proofs:
`select(?term,?list,?list)` - `zero_or_more`

### `selectchk/3`

Checks that an element can be selected from a list, returning the list of remaining elements.

Compilation flags:
`static`
Template:
`selectchk(Element,List,Remaining)`
Mode and number of proofs:
`selectchk(?term,?list,?list)` - `zero_or_one`

### `select/4`

Selects an element from a list, replacing it by a new element and returning the resulting list.

Compilation flags:
`static`
Template:
`select(Old,OldList,New,NewList)`
Mode and number of proofs:
`select(?term,?list,?term,?list)` - `zero_or_more`

### `selectchk/4`

Checks that an element from a list can be replaced by a new element, returning the resulting list.

Compilation flags:
`static`
Template:
`selectchk(Old,OldList,New,NewList)`
Mode and number of proofs:
`selectchk(?term,?list,?term,?list)` - `zero_or_one`

### `sort/2`

Sorts a list in ascending order (duplicated elements are removed).

Compilation flags:
`static`
Template:
`sort(List,Sorted)`
Mode and number of proofs:
`sort(+list,-list)` - `one`

### `sort/3`

Sorts a list using a user-specified comparison predicate modeled on the standard compare/3 predicate (duplicated elements are removed).

Compilation flags:
`static`
Template:
`sort(Closure,List,Sorted)`
Meta-predicate template:
`sort(3,*,*)`
Mode and number of proofs:
`sort(+callable,+list,-list)` - `one`

### `sort/4`

Sorts a list using the given key and order. @< and @> orders remove duplicates while @=< and @>= orders keep them. @< and @=< specify ascending order while @> and @>= specify descending order. When the key is zero, the whole term is used for comparisons.

Compilation flags:
`static`
Template:
`sort(Key,Order,List,Sorted)`
Mode and number of proofs:
`sort(+non_negative_integer,+atom,+list,-list)` - `one`

### `split/4`

Splits a list into sublists of a given length. Also returns a list with the remaining elements. Fails if the length is zero or negative.

Compilation flags:
`static`
Template:
`split(List,Length,Sublists,Remaining)`
Mode and number of proofs:
`split(+list,+integer,-list(list),-list)` - `zero_or_one`

### `sublist/2`

The first list is a sublist of the second.

Compilation flags:
`static`
Template:
`sublist(Sublist,List)`
Mode and number of proofs:
`sublist(?list,+list)` - `zero_or_more`

### `subsequence/3`

List is an interleaving of Subsequence and Remaining. Element order is preserved.

Compilation flags:
`static`
Template:
`subsequence(List,Subsequence,Remaining)`
Mode and number of proofs:
`subsequence(?list,?list,?list)` - `zero_or_more`

### `subsequence/4`

Generates subsequences of a given length from a list. Also returns the remaining elements. Element order is preserved.

Compilation flags:
`static`
Template:
`subsequence(List,Length,Subsequence,Remaining)`
Mode and number of proofs:
`subsequence(+list,+integer,?list,?list)` - `zero_or_more`

### `substitute/4`

Substitutes all occurrences of Old in List by New, returning NewList. Uses term equality for element comparison.

Compilation flags:
`static`
Template:
`substitute(Old,List,New,NewList)`
Mode and number of proofs:
`substitute(@term,@list,@term,-list)` - `one`

### `subtract/3`

Removes all elements in the second list from the first list, returning the list of remaining elements.

Compilation flags:
`static`
Template:
`subtract(List,Elements,Remaining)`
Mode and number of proofs:
`subtract(+list,+list,-list)` - `one`

### `suffix/2`

Suffix is a suffix of List.

Compilation flags:
`static`
Template:
`suffix(Suffix,List)`
Mode and number of proofs:
`suffix(?list,+list)` - `zero_or_more`

### `suffix/3`

Suffix is a suffix of length Length of List.

Compilation flags:
`static`
Template:
`suffix(Suffix,Length,List)`
Mode and number of proofs:
`suffix(?list,+integer,+list)` - `zero_or_one`
`suffix(?list,-integer,+list)` - `zero_or_more`

### `proper_suffix/2`

Suffix is a proper suffix of List.

Compilation flags:
`static`
Template:
`proper_suffix(Suffix,List)`
Mode and number of proofs:
`proper_suffix(?list,+list)` - `zero_or_more`

### `proper_suffix/3`

Suffix is a proper suffix of length Length of List.

Compilation flags:
`static`
Template:
`proper_suffix(Suffix,Length,List)`
Mode and number of proofs:
`proper_suffix(?list,+integer,+list)` - `zero_or_one`
`proper_suffix(?list,-integer,+list)` - `zero_or_more`

### `take/3`

Takes the first N elements of a list. Fails if the list have fewer than N elements.

Compilation flags:
`static`
Template:
`take(N,List,Elements)`
Mode and number of proofs:
`take(+integer,+list,-list)` - `zero_or_one`

### `drop/3`

Drops the first N elements of a list. Fails if the list have fewer than N elements.

Compilation flags:
`static`
Template:
`drop(N,List,Remaining)`
Mode and number of proofs:
`drop(+integer,+list,-list)` - `zero_or_one`

## Protected interface

(none)

## Private predicates

(none)

## Operators

(none)

## Remarks

(none)

See also

list, list(Type), numberlistp, varlistp