List processing

Author(s): The CLIP Group.

Version: 1.11#222 (2004/5/24, 13:8:7 CEST)

Version of last change: 1.11#142 (2003/12/31, 12:29:49 CET)

This module provides a set of predicates for list processing.

• Usage and interface (lists)
• Documentation on exports (lists)

Usage and interface (lists)

Documentation on exports (lists)

PREDICATE: nonsingle/1:

Usage: nonsingle(X)

• Description: X is not a singleton.

PREDICATE: append/3:

Usage: append(Xs, Ys, Zs)

• Description: Zs is Ys appended to Xs.

PREDICATE: reverse/2:

Usage: reverse(Xs, Ys)

• Description: Reverses the order of elements in Xs.
• The following properties should hold at call time: Xs is a list. (basic_props:list/1) Ys is any term. (basic_props:term/1)
• The following properties should hold upon exit: Xs is a list. (basic_props:list/1) Ys is a list. (basic_props:list/1)

PREDICATE: reverse/3:

Usage: reverse(A, B, C)

• Description: Reverse the order of elements in A, and append it with B.

PREDICATE: delete/3:

Usage: delete(L1, E, L2)

• Description: L2 is L1 without the ocurrences of E.

PREDICATE: delete_non_ground/3:

Usage: delete_non_ground(L1, E, L2)

• Description: L2 is L1 without the ocurrences of E. E can be a nonground term so that all the elements in L1 it unifies with will be deleted

PREDICATE: select/3:

Usage: select(X, Xs, Ys)

• Description: Xs and Ys have the same elements except for one occurrence of X.

PREDICATE: length/2:

General properties: length(A, B)

• The following properties hold globally: This predicate is understood natively by CiaoPP. (basic_props:native/1)

Usage 1: length(L, N)

• Description: Computes the length of L.
• The following properties should hold at call time: L is a list. (basic_props:list/1) N is a free variable. (term_typing:var/1)
• The following properties hold upon exit: L is a list. (basic_props:list/1) N is an integer. (basic_props:int/1)

Usage 2: length(L, N)

• Description: Outputs L of length N.
• The following properties should hold at call time: L is a free variable. (term_typing:var/1) N is an integer. (basic_props:int/1)
• The following properties hold upon exit: L is a list. (basic_props:list/1) N is an integer. (basic_props:int/1)

Usage 3: length(L, N)

• Description: Checks that L is of length N.
• The following properties should hold at call time: L is a list. (basic_props:list/1) N is an integer. (basic_props:int/1)
• The following properties hold upon exit: L is a list. (basic_props:list/1) N is an integer. (basic_props:int/1)

PREDICATE: nth/3:

nth(N, List, Elem)

N is the position in List of Elem. N counts from one.

Usage 1:

• Description: Unifies Elem and the Nth element of List.
• Call and exit should be compatible with: List is a list. (basic_props:list/1) Elem is any term. (basic_props:term/1)
• The following properties should hold at call time: N is an integer. (basic_props:int/1)
• The following properties should hold upon exit: List is a list. (basic_props:list/1) Elem is any term. (basic_props:term/1)

Usage 2:

• Description: Finds the positions where Elem is in List. Positions are found in ascending order.
• Call and exit should be compatible with: List is a list. (basic_props:list/1) Elem is any term. (basic_props:term/1)
• The following properties should hold at call time: N is a free variable. (term_typing:var/1)
• The following properties should hold upon exit: N is an integer. (basic_props:int/1) List is a list. (basic_props:list/1) Elem is any term. (basic_props:term/1)

PREDICATE: add_after/4:

Usage: add_after(L0, E0, E, L)

• Description: Adds element E after element E0 (or at end) to list L0 returning in L the new list (uses term comparison).
• The following properties should hold at call time: L0 is currently a term which is not a free variable. (term_typing:nonvar/1) E0 is currently a term which is not a free variable. (term_typing:nonvar/1) E is currently a term which is not a free variable. (term_typing:nonvar/1) L is a free variable. (term_typing:var/1)

PREDICATE: add_before/4:

Usage: add_before(L0, E0, E, L)

• Description: Adds element E before element E0 (or at start) to list L0 returning in L the new list (uses term comparison).
• The following properties should hold at call time: L0 is currently a term which is not a free variable. (term_typing:nonvar/1) E0 is currently a term which is not a free variable. (term_typing:nonvar/1) E is currently a term which is not a free variable. (term_typing:nonvar/1) L is a free variable. (term_typing:var/1)

PROPERTY: list1/2:

Meta-predicate with arguments: list1(?,pred(1)).

Usage: list1(X, Y)

• Description: X is a list of Ys of at least one element.

PREDICATE: dlist/3:

Usage: dlist(List, DList, Tail)

• Description: List is the result of removing Tail from the end of DList (makes a difference list from a list).

PREDICATE: list_concat/2:

Usage: list_concat(list(LL,list), list(L))

• Description: L is the concatenation of all the lists in LL.

PREDICATE: list_insert/2:

Usage: list_insert(List, Term)

• Description: Adds Term to the end of List if there is no element in List identical to Term.
• The following properties should hold at call time: List is a free variable. (term_typing:var/1) Term is currently a term which is not a free variable. (term_typing:nonvar/1)

PREDICATE: insert_last/3:

Usage: insert_last(L0, E, L)

• Description: Adds element E at end of list L0 returning L.
• The following properties should hold at call time: L0 is currently a term which is not a free variable. (term_typing:nonvar/1) E is currently a term which is not a free variable. (term_typing:nonvar/1) L is a free variable. (term_typing:var/1)

PREDICATE: contains_ro/2:

Usage:

• Description: Impure membership (does not instantiate a variable in its first argument.

PREDICATE: contains1/2:

Usage:

• Description: First membership.

PREDICATE: nocontainsx/2:

Usage: nocontainsx(L, X)

• Description: X is not identical to any element of L.

PREDICATE: last/2:

Usage: last(L, X)

• Description: X is the last element of list L.

PREDICATE: list_lookup/3:

Usage: list_lookup(List, Key, Value)

• Description: Same as list_lookup/4, but use -/2 as functor.

PREDICATE: list_lookup/4:

Usage: list_lookup(List, Functor, Key, Value)

• Description: Look up Functor(Key,Value) pair in variable ended key-value pair list L or else add it at the end.

PREDICATE: intset_insert/3:

Usage: intset_insert(A, B, Set)

• Description: Insert the element B in the ordered set of numbers A.

PREDICATE: intset_delete/3:

Usage: intset_delete(A, B, Set)

• Description: Delete from the ordered set A the element B.

PREDICATE: intset_in/2:

Usage: intset_in(E, Set)

• Description: Succeds iff E is element of Set

PREDICATE: intset_sequence/3:

Usage: intset_sequence(N, L1, L2)

• Description: Generates an ordered set of numbers from 0 to N-1, and append it to L1.

PREDICATE: intersection/3:

Usage: intersection(List1, List2, List)

• Description: List has the elements which are both in List1 and List2.
• The following properties should hold at call time: List1 is currently a term which is not a free variable. (term_typing:nonvar/1) List2 is currently a term which is not a free variable. (term_typing:nonvar/1) List is a free variable. (term_typing:var/1)

PREDICATE: union/3:

Usage: union(List1, List2, List)

• Description: List has the elements which are in List1 followed by the elements which are in List2 but not in List1.
• The following properties should hold at call time: List1 is currently a term which is not a free variable. (term_typing:nonvar/1) List2 is currently a term which is not a free variable. (term_typing:nonvar/1) List is a free variable. (term_typing:var/1)

PREDICATE: difference/3:

Usage: difference(List1, List2, List)

• Description: List has the elements which are in List1 but not in List2.
• The following properties should hold at call time: List1 is currently a term which is not a free variable. (term_typing:nonvar/1) List2 is currently a term which is not a free variable. (term_typing:nonvar/1) List is a free variable. (term_typing:var/1)

PROPERTY: sublist/2:

Usage: sublist(List1, List2)

• Description: List2 contains all the elements of List1.
• If the following properties should hold at call time: List2 is currently a term which is not a free variable. (term_typing:nonvar/1)

PROPERTY: subordlist/2:

Usage: subordlist(List1, List2)

• Description: List2 contains all the elements of List1 in the same order.
• If the following properties should hold at call time: List2 is currently a term which is not a free variable. (term_typing:nonvar/1)

PREDICATE: equal_lists/2:

Usage: equal_lists(List1, List2)

• Description: List1 has all the elements of List2, and vice versa.
• The following properties should hold at call time: List1 is currently a term which is not a free variable. (term_typing:nonvar/1) List2 is currently a term which is not a free variable. (term_typing:nonvar/1)

PREDICATE: list_to_list_of_lists/2:

Usage: list_to_list_of_lists(List, LList)

• Description: LList is the list of one element lists with elements of List.
• The following properties should hold at call time: List is currently a term which is not a free variable. (term_typing:nonvar/1) LList is a free variable. (term_typing:var/1)

PREDICATE: powerset/2:

Usage: powerset(List, LList)

• Description: LList is the powerset of List, i.e., the list of all lists which have elements of List. If List is ordered, LList and all its elements are ordered.
• The following properties should hold at call time: List is currently a term which is not a free variable. (term_typing:nonvar/1) LList is a free variable. (term_typing:var/1)

PREDICATE: cross_product/2:

Usage: cross_product(LList, List)

• Description: List is the cartesian product of the lists in LList, that is, the list of lists formed with one element of each list in LList, in the same order.
• The following properties should hold at call time: LList is currently a term which is not a free variable. (term_typing:nonvar/1) List is a free variable. (term_typing:var/1)

Go to the first, previous, next, last section, table of contents.