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);
First, there is a group of common list operations.
Append returns a new list with the elements of l followed by the element 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 values 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 corresponding 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 contains the second element of each tuple.
A second group of operations applies a function f or a Boolean predicate 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 otherwise.
Anysat returns 1 if any element of l satisfies p, and returns 0 otherwise.
Filter returns a new list containing only the elements of l that satisfy 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.
LISTS(2 ) | Rev: Tue Mar 31 02:42:39 GMT 2015 |