LISTS(2)LISTS(2)NAME
lists: allsat, anysat, append, combine, concat, delete, filter, find,
ismember, last, map, pair, partition, reverse, unpair- list operations
SYNOPSIS
include "lists.m"
lists := load Lists Lists->PATH;
append: fn[T](l: list of T, x: T): list of T;
combine: fn[T](l1: list of T, l2: list of T): list of T;
concat: fn[T](l1: list of T, l2: list of T): list of T;
delete: fn[T](x: T, l: list of T): list of T
for { T => eq: fn(a, b: T): int; };
find: fn[T](x: T, l: list of T): list of T
for { T => eq: fn(a, b: T): int; };
ismember: fn[T](x: T, l: list of T): int
for { T => eq: fn(a, b: T): int; };
last: fn[T](l: list of T): T;
pair: fn[T1, T2](l1: list of T1, l2: list of T2):
list of (T1, T2);
reverse: fn[T](l: list of T): list of T;
unpair: fn[T1, T2](l: list of (T1, T2)):
(list of T1, list of T2);
allsat: fn[T](p: ref fn(x: T): int, l: list of T): int;
anysat: fn[T](p: ref fn(x: T): int, l: list of T): int;
filter: fn[T](p: ref fn(x: T): int, l: list of T): list of T;
map: fn[T](f: ref fn(x: T): T, l: list of T): list of T;
partition: fn[T](p: ref fn(x: T): int, l: list of T):
(list of T, list of T);
DESCRIPTION
The module provides operations on lists of type T, which may be any
reference type, or string. Reference types are array, chan, list, mod‐
ule, and ref adt. None of the operations change their parameter lists:
they always return a new list.
First, there is a group of common list operations.
Append returns a new list with the elements of l followed by the ele‐
ment x.
Combine returns a new list that has the elements of both l1 and l2 in
no defined order.
Concat returns a new list that has the elements of l1 followed by the
elements of l2.
Delete returns a new list in which the first element of l that is equal
to x has been removed (all others remain). X must be an adt reference
type T with an operation T.eq that returns true (non-zero) if two val‐
ues of type T are considered equal.
Find finds the first instance of x in list l and returns the tail of l
with x at its head. Find returns nil if there is no instance of x in
l.
Ismember returns 1 if there is an element of l that is equal to x.
Last returns the value of the element at the end of list l. A run-time
error occurs if l is nil.
Pair takes two lists l1 and l2, and returns a new list of tuples
(v1, v2) in which each element of l1 has been paired with the corre‐
sponding element of l2. A run-time error occurs if the lists are not
equal in length.
Reverse returns a new list containing the elements of l in reverse
order.
Unpair takes a list of tuples (v1, v2) and returns a tuple of lists
(l1, l2) where l1 contains the first element of each tuple, and l2 con‐
tains the second element of each tuple.
A second group of operations applies a function f or a Boolean predi‐
cate p to each element of a list l, returning a transformed list or a
Boolean value. A predicate p must return non-zero if its parameter
value satisfies its condition, and must return zero if it does not.
Allsat returns 1 if all elements of l satisfy p, and returns 0 other‐
wise.
Anysat returns 1 if any element of l satisfies p, and returns 0 other‐
wise.
Filter returns a new list containing only the elements of l that sat‐
isfy p.
Map returns a new list in which each element of l has been transformed
by f (ie, if l is e0::e1::... then the result is f(e0)::f(e1)::...).
Partition returns a tuple of lists (l1, l2) of lists where l1 contains
all elements of l that satisfy p and l2 contains all elements of l that
do not satisfy p.
SOURCE
/appl/lib/lists.b
BUGS
The current implementation of polymorphism is limited to reference
types and strings, which in turn limits use of this module.
LISTS(2)
