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)