**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)