Package COM.INFORMATIMAGO.COMMON-LISP.CESARUM.LIST

This package exports list processing functions.
    

License:

    AGPL3
    
    Copyright Pascal J. Bourguignon 2003 - 2014
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.
    
    You should have received a copy of the GNU Affero General Public License
    along with this program.
    If not, see <http://www.gnu.org/licenses/>

(aget place indicator &optional default)
function
RETURN:   The value of the entry INDICATOR of the a-list PLACE, or DEFAULT.
(appendf g705 &rest lists)
macro
Append the LISTS at the end of the PLACE.
(circular-length list)
function
LIST must be either a proper-list or a circular-list, not a dotted-list.
RETURN: the total length ; the length of the stem ; the length of the circle.
(combine &rest args)
function
RETURN:  (elt args 0) x (elt args 1) x ... x (elt args (1- (length args)))
         = the set of tuples built taking one item in order from each list
           in args.
EXAMPLE: (COMBINE '(WWW FTP) '(EXA) '(COM ORG))) 
           --> ((WWW EXA COM) (WWW EXA ORG) (FTP EXA COM) (FTP EXA ORG))
(deepest tree)
function
RETURN:     The deepest list in the tree.
NOTE:       Iterative algorithm.
SEE-ALSO:   deepest-rec
(deepest-rec tree)
function
RETURN:     The deepest list in the tree.
NOTE:       Recursive algorithm.
SEE-ALSO:   deepest-iti
(depth tree)
function
RETURN:     The depth of the tree.
(ensure-circular list)
function
If list is not a circular list, then modify it to make it circular.
RETURN: LIST
(ensure-list object)
function
RETURN:         If OBJECT is a list then OBJECT, otherwise a fresh
                list containing OBJECT.
(equivalence-classes set &key test key)
function
RETURN: The equivalence classes of SET, via KEY, modulo TEST.
(flatten tree)
function
RETURN: A list containing all the elements of the `tree'.
(hashed-intersection set1 set2)
function
AUTHORS: Paul F. Dietz <dietz@dls.net>
         Thomas A. Russ <tar@sevak.isi.edu>
(iota count &optional start step)
function
RETURN:   A list containing the elements 
          (start start+step ... start+(count-1)*step)
          The start and step parameters default to 0 and 1, respectively. 
          This procedure takes its name from the APL primitive.
EXAMPLE:  (iota 5) => (0 1 2 3 4)
          (iota 5 0 -0.1) => (0 -0.1 -0.2 -0.3 -0.4)
(list-elements clist)
function
CLIST is any kind of list: proper-list, circular-list or dotted-list.
RETURN: for a proper list:     a copy of clist, the length of the list and 0;
        for a circular list:   a list of elements in the clist, the length of the stem, and the length of the circle;
        for a dotted list:     a list of the elements in the clist, the number of cons cells, and nil;
        for an atom:           a list of the atom, 0, and nil.
(list-insert-separator list separator)
function
RETURN:  A list composed of all the elements in `list'
         with `separator' in-between.
EXAMPLE: (list-insert-separator '(a b (d e f)  c) 'x)
         ==> (a x b x (d e f) x c)
(list-lengths list)
function
LIST is any kind of list: proper-list, circular-list or dotted-list.
RETURN: for a proper list, the length of the list and 0;
        for a circular list, the length of the stem, and the length of the circle;
        for a dotted list, the number of cons cells, and nil;
        for an atom, 0, and nil.
(list-trim bag list &key test key)
function
RETURN: A sublist of LIST with the elements in the BAG removed from
        both ends.
(make-circular-list size &key initial-element)
function
RETURN: a new circular list of length SIZE.
POST: (circular-length (make-circular-list size)) == (values size 0 size)
(make-list-of-random-numbers length &key modulo)
function
RETURN:  A list of length `length' filled with random numbers
MODULO:  The argument to RANDOM.
(map-cartesian-product fun &rest lists)
function
DO:         Call FUN with as arguments the elements of the cartesian
            products of the lists in LISTS.
RETURN:     A list of all the results of FUN.
EXAMPLE:    (map-cartesian-product (function list) '(1 2 3) '(a b c) '(11 22))
            --> ((1 a 11) (1 a 22) (1 b 11) (1 b 22) (1 c 11) (1 c 22)
                 (2 a 11) (2 a 22) (2 b 11) (2 b 22) (2 c 11) (2 c 22)
                 (3 a 11) (3 a 22) (3 b 11) (3 b 22) (3 c 11) (3 c 22))
(maptree fun &rest trees)
function
DO:     Calls FUN on each non-null atom of the TREES.
PRE:    The trees in TREES must be congruent, or else the result is
        pruned like the smallest tree.
RETURN: A tree congruent to the TREES, each node being the result of
        FUN (it may be a subtree).
(memq item list)
function
RETURN:   (MEMBER ITEM LIST :TEST (FUNCTION EQ))
(nsplit-list list position &key from-end)
function
PRE:            0<=POSITION<=(LENGTH LIST)
DO:             SPLIT THE LIST IN TWO AT THE GIVEN POSITION.
                (NSPLIT-LIST (LIST 'A 'B 'C) 0) --> NIL ; (A B C)
                (NSPLIT-LIST (LIST 'A 'B 'C) 1) --> (A) ; (B C)
                (NSPLIT-LIST (LIST 'A 'B 'C) 2) --> (A B) ; (C)
                (NSPLIT-LIST (LIST 'A 'B 'C) 3) --> (A B C) ; NIL
POSITION:       POSITION OF THE SPLIT; 
                WHEN FROM-START AND 0<=POSITION<=(LENGTH LIST),
                THAT'S THE LENGTH OF THE FIRST RESULT
FROM-START:     THE DEFAULT, SPLIT COUNTING FROM THE START.
FROM-END:       WHEN SET, COUNT FROM THE END OF THE LIST.
                 (NSPLIT-LIST L P :FROM-END T)
                 === (NSPLIT-LIST L (- (LENGTH L) P))
RETURN:         THE FIRST PART ; THE LAST PART
(nsplit-list-on-indicator list indicator)
function
RETURN: a list of sublists of list (the conses from list are reused),
        the list is splited between items a and b for which (indicator a b).
(plist-cleanup plist)
function
Returns a plist that has the same associations than PLIST, but with
a single occurence of each key and the first value found.

EXAMPLE:        (plist-cleanup '(:a 1 :b 2 :a 11 :c 3)) --> (:b 2 :c 3 :a 1)
(plist-get plist prop)
function
 Extract a value from a property list.
 PLIST is a property list, which is a list of the form
 (PROP1 VALUE1 PROP2 VALUE2...).  This function returns the value
 corresponding to the given PROP, or nil if PROP is not
 one of the properties on the list.
(plist-keys plist)
function
Returns a list of the properties in PLIST.
(plist-put plist prop value)
function
 Change value in PLIST of PROP to VALUE.
 PLIST is a property list, which is a list of the form
 (PROP1 VALUE1 PROP2 VALUE2 ...).  PROP is a symbol and VALUE is any object.
 If PROP is already a property on the list, its value is set to VALUE,
 otherwise the new PROP VALUE pair is added.  The new plist is returned;
 use `(setq x (plist-put x prop val))' to be sure to use the new value.
 The PLIST is modified by side effects.
(plist-remove plist prop)
function
DO:      (REMF PLIST PROP)
RETURN:  The modified PLIST.

PREPEND

(prependf g682 &rest lists)
macro
Prepend the LISTS at the beginning of the PLACE.
(proper-list-p object)
function
RETURN: whether OBJECT is a proper list
NOTE:   terminates with any kind of list, dotted, circular, etc.

PUSH*

(replace-tree dst src)
function
DO:     Copies the elements of the src tree into the dst tree.
        If dst is missing cons cells, structure sharing occurs.
RETURN: dst
(subsets set)
function
RETURN: The set of all subsets of the strict SET.
(transpose tree)
function
RETURN: A tree where all the CAR and CDR are exchanged.
(tree-difference a b &key test)
function
RETURN: A tree congruent to A and B where each node is = when the
        corresponding nodes are equal (as indicated by TEST),
        or (/= a-elem b-elem) otherwise.

EXAMPLE: (tree-difference '((a b c) 1 (d e f)) '((a b c) (1) (d x f)))
         --> ((= = = . =) (/= 1 (1)) (= (/= e x) = . =) . =)
(tree-find object tree &key key test)
function
RETURN: The object in TREE that matches OBJECT (using the KEY and TEST functions.
TREE:   A sexp.