cl-containers

API Reference

cl-containers

A generic container library for Common Lisp

METABANG.CL-CONTAINERS

A library of container classes and algorithms for Common Lisp.
  • Condition CONTAINER-ERROR  (CONTAINER-CONDITION, ERROR)
  • Condition ELEMENT-NOT-FOUND-ERROR  (CONTAINER-ERROR)
  • Generic-Function SAMPLE-ELEMENTS (container generator count)
    Return a list of count elements of the container uniformly at random using the generator. The sampling is done _with_ replacement.
  • Generic-Function SAMPLE-UNIQUE-ELEMENTS (container generator count)
    Return a list of count elements from the container sampled uniformly at random without replacement.
  • Generic-Function SAMPLE-ELEMENT (container generator)
    Return an element of the container uniformly at random using the generator.
  • Generic-Function SAMPLE-ITEM (container generator)
    Return an item of the container uniformly at random using the generator. Same as sample-element unless container is of type container-uses-nodes-mixin.
  • Generic-Function EMPTY! (abstract-container)
    Removes all items from the container and returns nil.
  • Generic-Function SOME-ITEM-P (container predicate)
    Returns the first item in the container for which predicate holds. Predicate should be a function of one argument for iteratable containers and a function of two arguments for associative containers.
  • Generic-Function EVERY-ITEM-P (container predicate)
    Returns true if every item in the container satisfies the predicate. Predicate should be a function of one argument for iteratable containers and a function of two arguments for associative containers.
  • Generic-Function NTH-ELEMENT (container index)
    Returns the nth element in the container's 'natural' order.
  • Generic-Function NTH-ITEM (container index)
    Returns the nth item in the container's 'natural' order. This is the same as nth-element unless the contaienr is of type container-uses-nodes-mixin.
  • Generic-Function ITEM-AT (indexed-container-mixin &rest indexes)
    Returns the item specified by the indexes.
  • Generic-Function (setf ITEM-AT) (value container &rest indexes)
  • Generic-Function ITEM-AT! (indexed-container-mixin value &rest indexes)
    [Destructively] modifies the item specified by the indexes to the value.
  • Generic-Function (setf ITEM-AT-1) (value container index)
  • Generic-Function FIND-ITEM (findable-container-mixin item)
    Find item in container using the container's test method for comparisons. The test method must take two parameters. The first will be the item being searched for; the second will be an item in the container. If the container has a key (keyed-container-mixin), then the test is performed on the item and the key of each element in the container. Find-item returns nil if the item is not found and it returns the element in the container if it is.
  • Generic-Function FIND-NODE (findable-container-mixin thing)
    Find node containing thing in container using the container's test method for comparisons. The test method must take two parameters. The first will be the item being searched for; the second will be an item in the container. If the container has a key (keyed-container-mixin), then the test is performed on the item and the key of each element in the container. Find-item returns nil if the thing is not found and it returns the node in the container if it is. Find-node is the same as find-element for containers that do not use nodes.
  • Generic-Function FIND-ELEMENT (findable-container-mixin thing)
    For now, compare find-item.
  • Generic-Function SEARCH-FOR-ITEM (container item &key test key)
    Hunt for the item in the container. Key and Test are as in member.
  • Generic-Function SEARCH-FOR-MATCH (container predicate &key key)
    Hunt for an item in the container that satisfies the predicate. Key is as in count-if.
  • Generic-Function ITERATE-NODES (iteratable-container-mixin function)
    Applies function to each node in the container. If the container doesn't have nodes, then this is equivalent to iterate-elements.
  • Generic-Function PRINT-CONTAINER (iteratable-container-mixin &optional stream)
    Prints the contents of container (using PRINT). Returns the container.
  • Generic-Function COLLECT-NODES (container &key filter transform)
    Returns a possibly filtered and possibly transformed list of the nodes in a container. If the container uses nodes, then the items are the nodes. If not, collect-nodes is equivalent to collect-elements.
  • Generic-Function COLLECT-ELEMENTS (container &key filter transform)
    Returns a possibly filtered and possibly transformed list of the elements in a container. If the container uses nodes, then the elements are the things 'in' the nodes. Warning: it is possible for the result to share structure with the original container.
  • Generic-Function COLLECT-KEY-VALUE (container &key filter transform)
    Iterate over the keys and values of the container and return a list of the ones that pass the filter function transformed by the transform function.
  • Generic-Function COLLECT-KEYS (container &key filter transform)
    Collects the `keys` of a container into a list. The `filter` and `transform` arguments should be `nil` or functions of one argument. If `filter` is non-nil, then the list returned will contain only `keys` that return true. If transform is non-nil, then it will be applied to each key that passes the filter.
  • Generic-Function ITERATE-VALUE-KEY (container function)
  • Generic-Function (setf FIRST-ELEMENT) (x y)
  • Function FIRST-ITEM (x)
  • Function LAST-ITEM (x)
  • Generic-Function DELETE-FIRST (ordered-container-mixin)
    Removes (and returns) the first item in an ordered container. Behavior is undefined if the container is empty.
  • Generic-Function DELETE-LAST (ordered-container-mixin)
    Removes (and returns) the last item in an ordered container. Behavior is undefined if the container is empty.
  • Generic-Function INSERT-ITEM (non-associative-container-mixin item)
    Adds item to the container
  • Generic-Function APPEND-ITEM (ordered-container item)
    Add an item to the end of an ordered container.
  • Generic-Function INSERT-NEW-ITEM (non-associative-container-mixin item &key test key)
    Adds item to the container unless it is already there
  • Generic-Function APPEND-NEW-ITEM (ordered-container item &key test key)
    Add an item to the end of an ordered container unless its already there.
  • Generic-Function INSERT-SEQUENCE (non-associative-container-mixin sequence)
    Adds each item in the sequence to the container in an upspecified order.
  • Generic-Function INSERT-LIST (non-associative-container-mixin list)
    Adds each item in the list to the container in an upspecified order.
  • Generic-Function DELETE-LIST (non-associative-container-mixin list)
    Deletes each item in the list from the container.
  • Generic-Function REVERSE-FIND (contents-as-hashtable-mixin value &key test)
    Finds the key in the associative-container whose value is VALUE.
  • Generic-Function ENSURE-SORTED (container)
    This method ensures that the sorted-list-container is sorted, and then returns the container.
  • Generic-Function FORCE-SORT (container)
    This method forces a sort on the next pertinent access of the container.
  • Generic-Function REMOVE-ITEMS-IF (container test)
    Removes items from a container that satisfy the test. The container is returned.
  • Generic-Function CONTAINER->ARRAY (ordered-container-mixin)
  • Generic-Function ELEMENT-POSITION (ordered-container-mixin element &key test key)
    Returns the position of element in container using test and key to match. Key defaults to identity and test defaults to eq.
  • Generic-Function REVERSE-CONTAINER (ordered-container-mixin)
    Destructively alters the elements/nodes of an ordered container so that they are reversed.
  • Generic-Function UNIQUE-ELEMENTS (container &key key)
  • Generic-Function UNIQUE-NODES (container &key key)
  • Generic-Function BEST-ELEMENT (container function &key key test filter)
  • Generic-Function BEST-NODE (container function &key key test filter)
  • Generic-Function BIGGEST-ITEM (heap)
  • Generic-Function CHILDREN (many-child-node)
  • Generic-Function COLLECT-ELEMENTS-STABLY (container &key filter transform)
  • Generic-Function COLLECT-ITEMS (object &rest args &key filter transform)
  • Generic-Function COLLECT-KEY-VALUE-STABLY (container)
  • Generic-Function COUNT-ELEMENTS (container item &key key test)
  • Generic-Function COUNT-ELEMENTS-IF (container test &key key)
  • Generic-Function DELETE-BIGGEST-ITEM (heap)
  • Generic-Function DELETE-ELEMENT (q item)
  • Generic-Function DELETE-ITEM (ordered-container-mixin item)
  • Generic-Function DELETE-ITEM-AFTER (list node)
  • Generic-Function DELETE-ITEM-AT (container &rest indexes)
  • Generic-Function DELETE-ITEM-BEFORE (list node)
  • Generic-Function DELETE-ITEM-IF (ordered-container-mixin test)
  • Generic-Function DELETE-NODE (tree node)
  • Generic-Function DEQUEUE (abstract-queue)
  • Generic-Function ENQUEUE (abstract-queue item)
  • Generic-Function EVERY-ELEMENT-P (array predicate)
  • Generic-Function EVERY-KEY-VALUE-P (container predicate)
  • Generic-Function FIND-CHILD-NODE (node child &key test key)
  • Generic-Function FIND-SET (item)
  • Generic-Function FIND-VALUE (container item)
  • Generic-Function FIRST-ELEMENT (x)
  • Generic-Function GRAFT-NODES (node1 node2)
  • Generic-Function INORDER-WALK (tree walk-fn)
  • Generic-Function INSERT-ITEM-AFTER (list node new-node)
  • Generic-Function INSERT-ITEM-AT (container item index)
    Inserts item at the specified index, increasing the index of all following elements
  • Generic-Function INSERT-ITEM-BEFORE (list node new-node)
  • Generic-Function INSERT-ITEM-ORDERED (list new-node)
  • Generic-Function INSERT-ITEM-ORDERED-ABOUT-NODE (list node new-node)
  • Generic-Function ITEM-AT-1 (container index)
  • Generic-Function ITEM-AT-1! (hash-table value index)
  • Generic-Function ITERATE-CONTAINER (iterator fn)
  • Generic-Function ITERATE-ELEMENTS (graph fn)
  • Generic-Function ITERATE-ELEMENTS-STABLY (container fn)
  • Generic-Function ITERATE-KEY-VALUE (container function)
  • Generic-Function ITERATE-KEY-VALUE-STABLY (container fn)
  • Generic-Function ITERATE-KEYS (container function)
  • Generic-Function ITERATE-LEFT (list item fn &optional inclusive?)
  • Generic-Function ITERATE-LEFT-NODES (list item fn)
  • Generic-Function ITERATE-RIGHT (list item fn &optional inclusive?)
  • Generic-Function ITERATE-RIGHT-NODES (list item fn)
  • Generic-Function LAST-ELEMENT (x)
  • Generic-Function (setf LAST-ELEMENT) (x y)
  • Generic-Function LEFT-AND-RIGHT-NODES-FOR-ITEM (list item)
  • Generic-Function LEFT-NODE-FOR-ITEM (list item)
  • Generic-Function MAKE-NODE-FOR-CONTAINER (container item &key)
  • Generic-Function NEXT-ITEM (x)
  • Generic-Function POP-ITEM (abstract-stack)
  • Generic-Function POSTORDER-WALK (tree walk-fn)
  • Generic-Function PREDECESSOR (sorted-container-mixin item)
    Return the item that comes *before* item in the container. Only makes sense for sorted containers. Raises an element-not-found-error if the item isn't present in the container.
  • Generic-Function PREORDER-WALK (tree walk-fn)
  • Generic-Function PUSH-ITEM (stack item)
  • Generic-Function REDUCE-CONTAINER (container function &rest args &key key initial-value start end)
  • Generic-Function REDUCE-ELEMENTS (container function &key key initial-value start end)
  • Generic-Function REDUCE-NODES (container function &key key initial-value start end)
  • Generic-Function REPLACE-ITEM (list node start-item &key length finish-item)
  • Generic-Function REPRESENTATIVE (container item)
  • Generic-Function REPRESENTATIVE-NODE (container item)
  • Generic-Function RIGHT-NODE-FOR-ITEM (list item)
  • Generic-Function SEARCH-FOR-ELEMENT (list item &key test key)
  • Generic-Function SEARCH-FOR-KEY (container key-to-find &key test key)
  • Generic-Function SEARCH-FOR-MATCHING-NODE (container predicate &key key)
  • Generic-Function SEARCH-FOR-NODE (container item &key test key)
  • Generic-Function SEARCH-FOR-NODE* (container item &key test key)
  • Generic-Function SOME-ELEMENT-P (array predicate)
  • Generic-Function SOME-KEY-VALUE-P (container predicate)
  • Generic-Function SORT-ELEMENTS (container sorter &key key)
  • Generic-Function SORT-KEYS (container sorter &key key)
  • Generic-Function SUCCESSOR (sorted-container-mixin item)
    Return the item that comes after item in the container. Only makes sense for sorted containers. Raises an element-not-found-error if the item isn't present in the container.
  • Generic-Function UPDATE-ITEM (list item)
  • Generic-Function (setf PACKAGES) (value container)
  • Generic-Function CONTAINER->LIST (graph)
  • Generic-Function CURRENT-ITEM (container)
  • Generic-Function ITERATE-CHILDREN (node fn)
    Calls `fn` on every child of `node`.
  • Generic-Function ITERATABLE-P (thing)
    Returns true if thing knows how to iterate-nodes.
  • Method ITERATABLE-P ((thing t))
  • Method ITERATABLE-P ((thing t))
  • Method ITERATABLE-P ((thing t))
  • Generic-Function KEY-VALUE-ITERATABLE-P (thing)
    Returns true if thing knows how to iterate-nodes.
  • Method KEY-VALUE-ITERATABLE-P ((thing t))
  • Method KEY-VALUE-ITERATABLE-P ((thing t))
  • Method KEY-VALUE-ITERATABLE-P ((thing t))
  • Class ABSTRACT-CONTAINER
    Inherited by all container classes, this is a good place to put those pesky superclasses you need everyone to inherit.
    No slots.
  • Class CONTAINER-NODE-MIXIN
    ELEMENT   Accessor: ELEMENT
  • Class PARENT-NODE-MIXIN  (CONTAINER-NODE-MIXIN)
    A mixin for nodes with parent pointers
    PARENT   Accessor: PARENT
  • Method (setf ITEM-AT) (value container &rest indexes)
  • Class INITIAL-CONTENTS-MIXIN  (BASIC-INITIAL-CONTENTS-MIXIN)
    No slots.
  • Class TEST-CONTAINER-MIXIN
    TEST   Reader: TEST
  • Class CONTAINER-USES-NODES-MIXIN  (ABSTRACT-CONTAINER)
    No slots.
  • Class ITERATABLE-CONTAINER-MIXIN  (SEARCHABLE-CONTAINER-MIXIN)
    No slots.
  • Class KEY-VALUE-ITERATABLE-CONTAINER-MIXIN  (ITERATABLE-CONTAINER-MIXIN)
    No slots.
  • Method ITERATE-CONTAINER (object fn)
  • Method COLLECT-ITEMS (object &rest args &key filter transform)
  • Class I-KNOW-MY-NODE-MIXIN
    MY-NODE   Accessor: MY-NODE
  • Method MAKE-NODE-FOR-CONTAINER ((container t) (item i-know-my-node-mixin) &key)
  • Class NON-ASSOCIATIVE-CONTAINER-MIXIN  (ABSTRACT-CONTAINER)
    A non associative container should implement at least empty-p, empty, insert-item and delete-item.
    No slots.
  • Method COLLECT-ELEMENTS ((object uses-contents-mixin) &rest args &key filter transform)
  • Method ITERATE-NODES ((object uses-contents-mixin) fn)
  • Class CONTENTS-AS-ARRAY-MIXIN  (USES-CONTENTS-MIXIN, ITERATABLE-CONTAINER-MIXIN)
    CONTENTS   Accessor: CONTENTS
  • Class CONTENTS-AS-LIST-MIXIN  (KEYED-CONTAINER-MIXIN, INITIAL-CONTENTS-MIXIN, ORDERED-CONTAINER-MIXIN, CONTENTS-AS-SEQUENCE-MIXIN)
    CONTENTS   Accessor: CONTENTS
  • Class LIST-CONTAINER  (CONTENTS-AS-LIST-MIXIN, CONCRETE-CONTAINER)
    No slots.
  • Class CONTENTS-AS-HASHTABLE-MIXIN  (USES-CONTENTS-MIXIN, KEY-VALUE-ITERATABLE-CONTAINER-MIXIN, FINDABLE-CONTAINER-MIXIN)
    CONTENTS   Accessor: CONTENTS
  • Class ASSOCIATIVE-CONTAINER-MIXIN  (INITIAL-CONTENTS-KEY-VALUE-MIXIN, INDEXED-CONTAINER-MIXIN)
    No slots.
  • Class ARRAY-CONTAINER  (ARRAY-CONTAINER-ABSTRACT, TYPED-CONTAINER-MIXIN, INITIAL-ELEMENT-MIXIN, ITERATABLE-CONTAINER-MIXIN, CONCRETE-CONTAINER)
    CONTENTS   Accessor: CONTENTS
  • Class SPARSE-ARRAY-CONTAINER  (ASSOCIATIVE-CONTAINER-MIXIN, CONTENTS-AS-HASHTABLE-MIXIN, TEST-CONTAINER-MIXIN, INITIAL-ELEMENT-MIXIN, BOUNDED-CONTAINER-MIXIN, CONCRETE-CONTAINER)
    DIMENSIONS   Reader: DIMENSIONS
    USE-FIXNUMS?   Reader: USE-FIXNUMS?
  • Class SIMPLE-ASSOCIATIVE-CONTAINER  (ASSOCIATIVE-CONTAINER-MIXIN, INITIAL-ELEMENT-MIXIN, CONTENTS-AS-HASHTABLE-MIXIN, TEST-CONTAINER-MIXIN, CONCRETE-CONTAINER)
    No slots.
  • Class ASSOCIATIVE-CONTAINER  (INITIAL-ELEMENT-MIXIN, CONTENTS-AS-HASHTABLE-MIXIN, TEST-CONTAINER-MIXIN, ASSOCIATIVE-CONTAINER-MIXIN, CONCRETE-CONTAINER)
    No slots.
  • Class BIASSOCIATIVE-CONTAINER-MIXIN  (ASSOCIATIVE-CONTAINER-MIXIN)
    No slots.
  • Class ALIST-CONTAINER  (BIASSOCIATIVE-CONTAINER-MIXIN, INITIAL-ELEMENT-MIXIN, KEY-VALUE-ITERATABLE-CONTAINER-MIXIN, USES-CONTENTS-MIXIN, CONCRETE-CONTAINER)
    TEST
  • Class STABLE-ASSOCIATIVE-CONTAINER  (KEY-VALUE-ITERATABLE-CONTAINER-MIXIN, ITERATABLE-CONTAINER-MIXIN, ASSOCIATIVE-CONTAINER-MIXIN)
    ASSOCIATIVE-CONTAINER
    NUMBERED-CONTAINER
    COUNTER   Reader: COUNTER
  • Method ITERATABLE-P ((thing iteratable-container-mixin))
  • Method KEY-VALUE-ITERATABLE-P ((thing key-value-iteratable-container-mixin))
  • Generic-Function MAKE-CONTAINER (class &rest args)
    Creates a new container of type class using the additional arguments (args).
  • Method MAKE-CONTAINER ((class symbol) &rest args)
  • Method MAKE-CONTAINER ((class symbol) &rest args)
  • Method MAKE-CONTAINER ((class symbol) &rest args)
  • Generic-Function EMPTY-P (abstract-container)
    Returns t if there are no items in the container.
  • Method EMPTY-P ((container t))
  • Method EMPTY-P ((container t))
  • Method EMPTY-P ((container t))
  • Method ITERATE-ELEMENTS ((container abstract-container) fn)
  • Method ITERATE-ELEMENTS ((container container-uses-nodes-mixin) fn)
  • Method FIND-ELEMENT ((container container-uses-nodes-mixin) (thing t))
  • Method DELETE-ITEM ((container container-uses-nodes-mixin) (item t))
  • Method DELETE-ELEMENT ((container container-uses-nodes-mixin) (thing t))
  • Method PRINT-CONTAINER ((container iteratable-container-mixin) &optional (stream *standard-output*))
  • Method NTH-ELEMENT ((container t) (index integer))
  • Method NTH-ELEMENT ((container iteratable-container-mixin) (index integer))
  • Method COLLECT-NODES ((container iteratable-container-mixin) &key filter transform)
  • Method COLLECT-ELEMENTS ((container iteratable-container-mixin) &key filter transform)
  • Method SEARCH-FOR-ITEM ((container iteratable-container-mixin) item &key (test (test container)) (key 'identity))
  • Method SEARCH-FOR-ELEMENT ((container iteratable-container-mixin) item &key (test (test container)) (key 'identity))
  • Method SEARCH-FOR-NODE ((container iteratable-container-mixin) item &key (test (test container)) (key 'identity))
  • Method SEARCH-FOR-MATCH ((container iteratable-container-mixin) predicate &key (key 'identity))
  • Method SEARCH-FOR-MATCHING-NODE ((container iteratable-container-mixin) predicate &key (key 'identity))
  • Method SEARCH-FOR-NODE ((container container-uses-nodes-mixin) (item t) &key (test (test container)) (key 'identity))
  • Method SEARCH-FOR-NODE ((container container-uses-nodes-mixin) (item container-node-mixin) &key (test (test container)) (key 'identity))
  • Method SEARCH-FOR-NODE* ((container container-uses-nodes-mixin) (item t) &key (test (test container)) (key 'identity))
  • Method SEARCH-FOR-NODE* ((container container-uses-nodes-mixin) (item container-node-mixin) &key (test (test container)) (key 'identity))
  • Method BEST-NODE (container function &key (key 'identity) (test '>) (filter nil))
  • Method BEST-ELEMENT (container function &key (key 'identity) (test '>) (filter nil))
  • Method REDUCE-CONTAINER ((container iteratable-container-mixin) function &rest args &key (key 'identity) (initial-value nil initial-value-supplied-p) (start 0) end)
  • Method REDUCE-ELEMENTS ((container iteratable-container-mixin) function &key (key 'identity) (initial-value nil initial-value-supplied-p) (start 0) end)
  • Method REDUCE-NODES ((container iteratable-container-mixin) function &key (key 'identity) (initial-value nil initial-value-supplied-p) (start 0) end)
  • Method DELETE-ITEM-IF ((container iteratable-container-mixin) test)
  • Method FIRST-ELEMENT ((container iteratable-container-mixin))
  • Method (setf FIRST-ELEMENT) (value (container iteratable-container-mixin))
  • Method DELETE-ITEM ((container container-uses-nodes-mixin) (item i-know-my-node-mixin))
  • Method INSERT-NEW-ITEM ((container searchable-container-mixin) item &key (test (test container)) (key (key container)))
  • Method SUCCESSOR ((container container-uses-nodes-mixin) (item t))
  • Method PREDECESSOR ((container container-uses-nodes-mixin) (item t))
  • Method EMPTY-P ((container contents-as-sequence-mixin))
  • Method SORT-ELEMENTS ((container contents-as-sequence-mixin) sorter &key (key 'identity))
  • Method EMPTY! ((container contents-as-array-mixin))
  • Method SEARCH-FOR-ITEM ((container contents-as-array-mixin) item &key (test (test container)) (key 'identity))
  • Method FIND-ITEM ((container contents-as-array-mixin) item)
  • Method SOME-ITEM-P ((container iteratable-container-mixin) (predicate function))
  • Method EVERY-ITEM-P ((container iteratable-container-mixin) (predicate function))
  • Method SOME-ELEMENT-P ((container iteratable-container-mixin) (predicate function))
  • Method EVERY-ELEMENT-P ((container iteratable-container-mixin) (predicate function))
  • Method INSERT-ITEM ((container contents-as-list-mixin) item)
  • Method APPEND-ITEM ((container contents-as-list-mixin) item)
  • Method APPEND-NEW-ITEM ((container contents-as-list-mixin) item &key (test 'eq) (key 'identity))
  • Method EMPTY-P ((container contents-as-list-mixin))
  • Method EMPTY! ((container contents-as-list-mixin))
  • Method SEARCH-FOR-ITEM ((container contents-as-list-mixin) item &key (test (test container)) (key 'identity))
  • Method EMPTY! ((container contents-as-hashtable-mixin))
  • Method SEARCH-FOR-ITEM ((container contents-as-hashtable-mixin) item &key (test (test container)) (key 'identity))
  • Method ITERATE-NODES ((container contents-as-hashtable-mixin) fn)
  • Method ITERATE-KEYS ((container contents-as-hashtable-mixin) function)
  • Method COLLECT-KEY-VALUE ((container key-value-iteratable-container-mixin) &rest args &key filter transform)
  • Method FIND-ITEM ((container contents-as-hashtable-mixin) item)
  • Method REVERSE-FIND ((container contents-as-hashtable-mixin) value &key (test (test container)))
  • Method FIND-VALUE ((container contents-as-hashtable-mixin) item)
  • Method ITEM-AT! ((object stable-associative-container) value &rest indexes)
  • Method ITEM-AT ((object stable-associative-container) &rest indexes)
  • Method ITERATE-KEYS ((container stable-associative-container) fn)
  • Method ITERATE-NODES ((container stable-associative-container) fn)
  • Method ITERATE-ELEMENTS-STABLY ((container stable-associative-container) fn)
  • Method ITERATE-KEY-VALUE ((container stable-associative-container) fn)
  • Method COLLECT-KEYS ((container stable-associative-container) &rest args &key filter transform)
  • Method ITERATE-KEY-VALUE-STABLY ((container stable-associative-container) fn)
  • Method COLLECT-KEY-VALUE-STABLY ((container stable-associative-container))
  • Method COLLECT-ELEMENTS-STABLY ((container iteratable-container-mixin) &key filter transform)
  • Method EMPTY! ((container stable-associative-container))
  • Method ITEM-AT! ((container associative-array) value &rest indexes)
  • Method ITEM-AT ((container associative-array) &rest indexes)
  • Method ITERATE-NODES ((container associative-array) fn)
  • Method DIMENSIONS ((container associative-array))
  • Method FIND-ITEM ((container container-uses-nodes-mixin) (item t))
  • Method INSERT-ITEM ((container container-uses-nodes-mixin) (item t))
  • Function COLLECT-USING (map-fn filter &rest args)
    Collects stuff by applying the map-fn to the arguments. Assumes that the map-fn signature has the function to be applied as its last argument.
  • Function COUNT-USING (map-fn filter &rest args)
    Counts stuff by applying the map-fn to the arguments. Assumes that the map-fn signature has the function to be applied as its last argument.
  • Method ELEMENT-POSITION ((container iteratable-container-mixin) element &key (test 'eq) (key 'identity))
  • Method ELEMENT-POSITION ((container contents-as-sequence-mixin) element &key (test 'eq) (key 'identity))
  • Method REVERSE-CONTAINER ((container ordered-container-mixin))
  • Class ABSTRACT-QUEUE  (INITIAL-CONTENTS-MIXIN, ORDERED-CONTAINER-MIXIN)
    No slots.
  • Method ENQUEUE ((queue abstract-queue) item)
  • Method DEQUEUE ((queue abstract-queue))
  • Method EMPTY! ((q abstract-queue))
  • Method FIRST-ELEMENT ((q abstract-queue))
  • Method DELETE-FIRST ((q abstract-queue))
  • Class PRIORITY-QUEUE-ON-CONTAINER  (ITERATABLE-CONTAINER-MIXIN, SORTED-CONTAINER-MIXIN, FINDABLE-CONTAINER-MIXIN, CONCRETE-CONTAINER, ABSTRACT-QUEUE)
    CONTAINER   Reader: CONTAINER
  • Method INSERT-ITEM ((q priority-queue-on-container) item)
  • Method DELETE-FIRST ((q priority-queue-on-container))
  • Method EMPTY-P ((q priority-queue-on-container))
  • Method EMPTY! ((q priority-queue-on-container))
  • Method FIRST-ELEMENT ((q priority-queue-on-container))
  • Method (setf FIRST-ELEMENT) (value (q priority-queue-on-container))
  • Method FIND-ITEM ((q priority-queue-on-container) (item t))
  • Method FIND-NODE ((q priority-queue-on-container) (item t))
  • Method FIND-ELEMENT ((q priority-queue-on-container) (item t))
  • Method DELETE-ITEM ((q priority-queue-on-container) (item t))
  • Method DELETE-NODE ((q priority-queue-on-container) (item t))
  • Method DELETE-ELEMENT ((q priority-queue-on-container) (item t))
  • Method DELETE-ITEM-IF (test (q priority-queue-on-container))
  • Method ITERATE-NODES ((q priority-queue-on-container) fn)
  • Method ITERATE-ELEMENTS ((q priority-queue-on-container) fn)
  • Class BASIC-QUEUE  (ABSTRACT-QUEUE, ITERATABLE-CONTAINER-MIXIN, CONCRETE-CONTAINER)
    A simple FIFO queue implemented as a list with extra bookkeeping for efficiency.
    QUEUE   Accessor: QUEUE-QUEUE
    INDEXER   Accessor: QUEUE-HEADER
  • Method INSERT-ITEM ((q basic-queue) (item t))
    Add an item to the queue.
  • Method DELETE-FIRST ((q basic-queue))
  • Method EMPTY-P ((q basic-queue))
  • Method ITERATE-NODES ((q basic-queue) fn)
  • Method FIRST-ELEMENT ((q basic-queue))
    Returns the first item in a queue without changing the queue.
  • Method (setf FIRST-ELEMENT) (value (q basic-queue))
    Returns the first item in a queue without changing the queue.
  • Method EMPTY! ((q basic-queue))
    Empty a queue of all contents.
  • Method DELETE-ITEM ((queue basic-queue) item)
  • Method (setf FIRST-ELEMENT) (value (stack abstract-stack))
  • Method PUSH-ITEM ((stack abstract-stack) item)
  • Class STACK-CONTAINER  (USES-CONTENTS-MIXIN, ABSTRACT-STACK, CONCRETE-CONTAINER)
    CONTENTS   Reader: CONTENTS
    CONTAINER-TYPE   Reader: CONTAINER-TYPE
  • Method FIRST-ELEMENT ((container stack-container))
  • Method (setf FIRST-ELEMENT) (value (container stack-container))
  • Method POP-ITEM ((container stack-container))
  • Method INSERT-ITEM ((container stack-container) item)
  • Method EMPTY-P ((container stack-container))
  • Method EMPTY! ((container stack-container))
  • Method SEARCH-FOR-ITEM ((container stack-container) item &key (test 'eq) (key 'identity))
  • Class ROOTED-TREE-CONTAINER  (ABSTRACT-TREE-CONTAINER)
    Base class of all trees with roots.
    ROOT   Accessor: ROOT
  • Class MANY-CHILD-NODE  (CONTAINER-NODE-MIXIN, ITERATABLE-CONTAINER-MIXIN)
    No slots.
  • Method ITERATE-CHILDREN ((node many-child-node) fn)
  • Method FIND-CHILD-NODE ((node many-child-node) child &key (test #'eq) (key #'identity))
  • Class MANY-ORDERED-CHILD-NODE  (MANY-CHILD-NODE, VECTOR-CONTAINER-MIXIN)
    A node with many ordered children is a vector
    No slots.
  • Method CHILDREN ((node many-ordered-child-node))
  • Class MANY-UNORDERED-CHILD-NODE  (MANY-CHILD-NODE, CONTENTS-AS-LIST-MIXIN)
    Children are unordered
    CONTENTS   Accessor: CONTENTS
  • Class BINARY-SEARCH-TREE  (CONTAINER-USES-NODES-MIXIN, INITIAL-CONTENTS-MIXIN, SORTED-CONTAINER-MIXIN, FINDABLE-CONTAINER-MIXIN, ITERATABLE-CONTAINER-MIXIN, ROOTED-TREE-CONTAINER, CONCRETE-CONTAINER)
    TREE-SIZE   Accessor: TREE-SIZE
  • Method MAKE-NODE-FOR-CONTAINER ((tree binary-search-tree) (item t) &key)
  • Method EMPTY-P ((tree binary-search-tree))
  • Method EMPTY! ((tree binary-search-tree))
  • Method FIND-ITEM ((tree binary-search-tree) (item bst-node))
  • Method FIND-NODE ((tree binary-search-tree) (item t))
  • Method FIND-SUCCESSOR-NODE ((tree binary-search-tree) (item t))
  • Method FIRST-ELEMENT ((node bst-node))
  • Method (setf FIRST-ELEMENT) (value (node bst-node))
  • Method FIRST-ELEMENT ((tree binary-search-tree))
  • Method (setf FIRST-ELEMENT) (value (tree binary-search-tree))
  • Method LAST-ELEMENT ((node bst-node))
  • Method LAST-ELEMENT ((tree binary-search-tree))
  • Method (setf LAST-ELEMENT) (value (node bst-node))
  • Method (setf LAST-ELEMENT) (value (tree binary-search-tree))
  • Method SUCCESSOR ((tree binary-search-tree) (node bst-node))
  • Method PREDECESSOR ((tree binary-search-tree) (node bst-node))
  • Method DELETE-NODE ((tree binary-search-tree) (node bst-node))
  • Method DELETE-NODE ((tree binary-search-tree) (node bst-node))
  • Method DELETE-ITEM ((tree binary-search-tree) (node bst-node))
  • Method DELETE-ITEM ((tree binary-search-tree) (item t))
  • Method DELETE-ITEM-IF (test (tree binary-search-tree))
    Iterate over the nodes of the tree, deleting them if they match test.
  • Method ITERATE-NODES ((tree binary-search-tree) fn)
  • Method INORDER-WALK ((tree binary-search-tree) walk-fn)
  • Method PREORDER-WALK ((tree binary-search-tree) walk-fn)
  • Method POSTORDER-WALK ((tree binary-search-tree) walk-fn)
  • Class RED-BLACK-TREE  (BINARY-SEARCH-TREE)
    EMPTY-NODE   Reader: EMPTY-NODE
  • Method MAKE-NODE-FOR-CONTAINER ((tree red-black-tree) (item t) &key)
  • Method INSERT-ITEM ((tree red-black-tree) (item bst-node))
  • Method DELETE-NODE ((tree red-black-tree) (item red-black-node))
  • Method ITEM-AT ((tree binary-search-tree) &rest indexes)
  • Method INSERT-ITEM ((tree splay-tree) (node bst-node))
  • Method ITEM-AT ((tree splay-tree) &rest indexes)
  • Method FIND-ITEM ((tree splay-tree) (node bst-node))
  • Method DELETE-NODE ((tree splay-tree) (node bst-node))
  • Method DELETE-ITEM ((tree splay-tree) (item t))
  • Method DELETE-ITEM-AT ((tree splay-tree) &rest indexes)
  • Method INSERT-LIST ((container list-container) list)
  • Method FIRST-ELEMENT ((container list-container))
  • Method (setf FIRST-ELEMENT) (value (container list-container))
  • Method DELETE-ITEM ((container list-container) item)
  • Method FIND-ITEM ((container list-container) item)
  • Method DELETE-FIRST ((container list-container))
  • Method NTH-ELEMENT ((container list-container) (index integer))
  • Method ITEM-AT ((container list-container) &rest indexes)
  • Method LAST-ELEMENT ((container list-container))
  • Method (setf LAST-ELEMENT) (value (container list-container))
  • Class SORTED-LIST-CONTAINER  (SORTED-CONTAINER-MIXIN, LIST-CONTAINER, CONCRETE-CONTAINER)
    A list container that keeps its items sorted as needed. This uses 'sort' so it best for small containers.
    DIRTY?   Reader: DIRTY?
    STABLE?   Accessor: STABLE?
  • Method INSERT-LIST ((container sorted-list-container) (list t))
  • Method INSERT-ITEM ((container sorted-list-container) (item t))
  • Method DELETE-ITEM ((container sorted-list-container) (item t))
  • Method FIRST-ELEMENT ((container sorted-list-container))
  • Method (setf FIRST-ELEMENT) (value (container sorted-list-container))
  • Method DELETE-FIRST ((container sorted-list-container))
  • Method ITEM-AT ((container sorted-list-container) &rest indexes)
  • Method PRINT-CONTAINER ((container sorted-list-container) &optional (stream *standard-output*))
  • Method ITERATE-NODES ((container sorted-list-container) fn)
  • Method COLLECT-ELEMENTS ((container sorted-list-container) &key filter transform)
  • Class DLIST-CONTAINER-NODE  (CONTAINER-NODE-MIXIN)
    A double-linked list node
    NEXT-ITEM   Accessor: NEXT-ITEM
    PREVIOUS-ITEM   Accessor: PREVIOUS-ITEM
    ELEMENT
  • Class DLIST-CONTAINER  (ORDERED-CONTAINER-MIXIN, ITERATABLE-CONTAINER-MIXIN, CONTAINER-USES-NODES-MIXIN, CONCRETE-CONTAINER)
    A double-linked list
    FIRST-ELEMENT   Accessor: FIRST-ELEMENT
    LAST-ELEMENT   Accessor: LAST-ELEMENT
    SIZE   Accessor: SIZE
  • Method MAKE-NODE-FOR-CONTAINER ((container dlist-container) (item t) &rest args)
  • Method EMPTY! ((container dlist-container))
  • Method INSERT-ITEM ((list dlist-container) (node dlist-container-node))
  • Method INSERT-ITEM-AFTER ((list dlist-container) node item)
  • Method INSERT-ITEM-AFTER ((list dlist-container) (node dlist-container-node) item)
  • Method INSERT-ITEM-BEFORE ((list dlist-container) node item)
  • Method INSERT-ITEM-BEFORE ((list dlist-container) (node dlist-container-node) item)
  • Method DELETE-ITEM-AFTER ((list dlist-container) (node dlist-container-node))
  • Method DELETE-ITEM-BEFORE ((list dlist-container) (node dlist-container-node))
  • Method DELETE-ITEM ((list dlist-container) item)
  • Method DELETE-ITEM ((list dlist-container) (node dlist-container-node))
  • Method ITEM-AT ((list dlist-container) &rest indexes)
  • Method REPLACE-ITEM ((list dlist-container) (node dlist-container-node) item &key (length 1) finish-item)
  • Method REPLACE-ITEM ((list dlist-container) (node dlist-container-node) (start-item dlist-container-node) &key (length 1) (finish-item start-item))
  • Method SUCCESSOR ((container dlist-container) (node dlist-container-node))
  • Method PREDECESSOR ((container dlist-container) (node dlist-container-node))
  • Class SORTED-DLIST-CONTAINER  (SORTED-CONTAINER-MIXIN, DLIST-CONTAINER)
    A persistently sorted double-linked list
    No slots.
  • Method INSERT-ITEM ((list sorted-dlist-container) (node dlist-container-node))
  • Method INSERT-ITEM-ORDERED-ABOUT-NODE ((list sorted-dlist-container) (node dlist-container-node) (new-node dlist-container-node))
  • Method INSERT-ITEM-ORDERED-ABOUT-NODE ((list sorted-dlist-container) (node t) (new-node dlist-container-node))
  • Method INSERT-ITEM-ORDERED-ABOUT-NODE ((list sorted-dlist-container) (node t) (new-node t))
  • Method INSERT-ITEM-ORDERED ((list sorted-dlist-container) (new-node dlist-container-node))
  • Method INSERT-ITEM-ORDERED ((list sorted-dlist-container) (new-node t))
  • Method DELETE-ITEM ((list sorted-dlist-container) item)
  • Method DELETE-ITEM ((list sorted-dlist-container) (item i-know-my-node-mixin))
  • Method LEFT-NODE-FOR-ITEM ((list sorted-dlist-container) (item t))
  • Method RIGHT-NODE-FOR-ITEM ((list sorted-dlist-container) (item t))
  • Method LEFT-AND-RIGHT-NODES-FOR-ITEM ((list sorted-dlist-container) (item t))
  • Method ITERATE-LEFT-NODES ((list sorted-dlist-container) (item dlist-container-node) fn)
  • Method ITERATE-LEFT-NODES ((list sorted-dlist-container) (item i-know-my-node-mixin) fn)
  • Method ITERATE-LEFT-NODES ((list sorted-dlist-container) (item t) fn)
  • Method ITERATE-RIGHT-NODES ((list sorted-dlist-container) (item dlist-container-node) fn)
  • Method ITERATE-RIGHT-NODES ((list sorted-dlist-container) (item i-know-my-node-mixin) fn)
  • Method ITERATE-RIGHT-NODES ((list sorted-dlist-container) (item t) fn)
  • Method ITERATE-LEFT ((list sorted-dlist-container) (item dlist-container-node) fn &optional (inclusive? nil))
  • Method ITERATE-LEFT ((list sorted-dlist-container) (item i-know-my-node-mixin) fn &optional (inclusive? nil))
  • Method ITERATE-LEFT ((list sorted-dlist-container) (item t) fn &optional (inclusive? nil))
  • Method ITERATE-RIGHT ((list sorted-dlist-container) (item dlist-container-node) fn &optional (inclusive? nil))
  • Method ITERATE-RIGHT ((list sorted-dlist-container) (item i-know-my-node-mixin) fn &optional (inclusive? nil))
  • Method ITERATE-RIGHT ((list sorted-dlist-container) (item t) fn &optional (inclusive? nil))
  • Method UPDATE-ITEM ((list sorted-dlist-container) (node dlist-container-node))
  • Method UPDATE-ITEM ((list sorted-dlist-container) (item i-know-my-node-mixin))
  • Method UPDATE-ITEM ((list sorted-dlist-container) item)
  • Class BAG-CONTAINER  (ABSTRACT-BAG/SET-CONTAINER, CONCRETE-CONTAINER)
    CONTENTS   Reader: CONTENTS
  • Method INSERT-ITEM ((container bag-container) item)
  • Method EMPTY-P ((container abstract-bag/set-container))
  • Method EMPTY! ((container abstract-bag/set-container))
  • Method SEARCH-FOR-ITEM ((container abstract-bag/set-container) item &key (test #'eq) (key #'identity))
  • Method SEARCH-FOR-MATCH ((container abstract-bag/set-container) predicate &key (key 'identity))
  • Method DELETE-ITEM ((container abstract-bag/set-container) item)
  • Method FIND-ITEM ((container abstract-bag/set-container) item)
  • Class SET-CONTAINER  (ABSTRACT-BAG/SET-CONTAINER, CONCRETE-CONTAINER)
    CONTENTS   Reader: CONTENTS
  • Method INSERT-ITEM ((container bag/set-container) item)
  • Method DELETE-ITEM ((container bag/set-container) item)
  • Method SEARCH-FOR-ITEM ((container bag/set-container) item &key (test 'eq) (key 'identity))
  • Method ITERATE-NODES ((container bag/set-container) fn)
  • Method FIND-ITEM ((container bag/set-container) item)
  • Method FIND-VALUE ((container bag/set-container) item)
  • Class KEYED-BAG/SET-CONTAINER  (BAG/SET-CONTAINER)
    KEY-MAP   Reader: KEY-MAP
  • Method INSERT-ITEM ((container keyed-bag/set-container) item)
  • Method DELETE-ITEM ((container keyed-bag/set-container) item)
  • Method FIND-ITEM ((container keyed-bag/set-container) item)
  • Method ITERATE-NODES ((container keyed-bag/set-container) fn)
  • Class RING-BUFFER  (ABSTRACT-QUEUE, BOUNDED-CONTAINER-MIXIN, ITERATABLE-CONTAINER-MIXIN, CONCRETE-CONTAINER)
    CONTENTS   Reader: CONTENTS
    BUFFER-START   Reader: BUFFER-START
    BUFFER-END   Reader: BUFFER-END
    TOTAL-SIZE   Reader: TOTAL-SIZE
  • Method MAKE-CONTAINER ((class (eql 'ring-buffer)) &rest args)
  • Method ITEM-AT ((container ring-buffer) &rest indexes)
  • Method ITEM-AT! ((container ring-buffer) value &rest indexes)
  • Method NEXT-ITEM ((container ring-buffer))
  • Method CURRENT-ITEM ((container ring-buffer))
  • Method INSERT-ITEM ((container ring-buffer) item)
  • Method DELETE-FIRST ((container ring-buffer))
  • Method EMPTY! ((container ring-buffer))
  • Method FIRST-ELEMENT ((container ring-buffer))
  • Method (setf FIRST-ELEMENT) (value (container ring-buffer))
  • Method ITERATE-NODES ((container ring-buffer) fn)
  • Function MERGE-ELEMENTS (container merge-fn initial-fn &key (key 'identity) (test 'equal) (argument 'identity) (return :both) (filter (constantly t)))
  • Function MERGE-NODES (container merge-fn initial-fn &key (key 'identity) (test 'equal) (argument 'identity) (return :both) (filter (constantly t)))
  • Function ELEMENT-COUNTS (container &key (test 'equal) (key 'identity) (sort nil) (sort-on :counts) (return :both) (weight (constantly 1)) (filter (constantly t)))
  • Function NODE-COUNTS (container &key (test 'equal) (key 'identity) (sort nil) (sort-on :counts) (return :both) (weight (constantly 1)) (filter (constantly t)))
  • Function MAP-WINDOW-OVER-ELEMENTS (container window-size window-step function &key duplicate-ends?)
    Moves a windows of size `window-size` across the elements of `container`, stepping by `window-step` each time. At each step, it applies function `fn` to the elements in the current window (as a list).
  • Function MAP-WINDOW-OVER-NODES (container window-size window-step function &key duplicate-ends?)
    Moves a windows of size `window-size` across the elements of `container`, stepping by `window-step` each time. At each step, it applies function `fn` to the elements in the current window (as a list).
  • Function COLLECT-WINDOW-OVER-ELEMENTS (container window-size window-step &key (transform 'identity) duplicate-ends?)
    Moves a windows of size `window-size` across the elements of `container`, stepping by `window-step` each time. At each step, it applies function `fn` to the elements in the current window (as a list).
  • Function COLLECT-WINDOW-OVER-NODES (container window-size window-step &key (transform 'identity) duplicate-ends?)
    Moves a windows of size `window-size` across the elements of `container`, stepping by `window-step` each time. At each step, it applies function `fn` to the elements in the current window (as a list).
  • Function MAP-PAIRS (container fn)
  • Function COLLECT-PAIRS (elements)
  • Method UNIQUE-ELEMENTS ((container iteratable-container-mixin) &key (key 'identity))
  • Method UNIQUE-ELEMENTS ((container list) &key (key 'identity))
  • Method UNIQUE-NODES ((container iteratable-container-mixin) &key (key 'identity))
  • Method UNIQUE-NODES ((container list) &key (key 'identity))
  • Method SOME-KEY-VALUE-P ((container associative-container-mixin) (predicate t))
  • Method EVERY-KEY-VALUE-P ((container associative-container-mixin) (predicate t))
  • Method COLLECT-KEYS ((container associative-container-mixin) &key (filter nil) (transform 'identity))
  • Method SEARCH-FOR-KEY ((container associative-container-mixin) key-to-find &key test key)
  • Method REMOVE-ITEMS-IF ((container iteratable-container-mixin) test)
  • Method REMOVE-ITEMS-IF ((container associative-container-mixin) test)
  • Method COUNT-ELEMENTS ((container iteratable-container-mixin) item &key (key 'identity) (test 'eql))
  • Method COUNT-ELEMENTS ((container list) item &key (key 'identity) (test 'eql))
  • Method COUNT-ELEMENTS-IF ((container iteratable-container-mixin) test &key (key 'identity))
  • Method COUNT-ELEMENTS-IF ((container list) test &key (key 'identity))
  • Method MAKE-CONTAINER ((class (eql 'array-container)) &rest args)
  • Method ITEM-AT ((container array-container) &rest indexes)
  • Method ITEM-AT! ((container array-container) value &rest indexes)
  • Method DIMENSIONS ((container array-container))
  • Method ITERATE-NODES ((container array-container) fn)
  • Method NTH-ELEMENT ((container array-container) (index integer))
  • Method ITEM-AT ((container sparse-array-container) &rest indexes)
  • Method ITEM-AT! ((container sparse-array-container) value &rest indexes)
  • Method ITEM-AT-1 ((container simple-associative-container) index)
  • Method ITEM-AT-1! ((container simple-associative-container) value index)
  • Method (setf ITEM-AT-1) (value container index)
  • Method ITEM-AT ((container simple-associative-container) &rest indexes)
  • Method ITEM-AT! ((container simple-associative-container) value &rest indexes)
  • Method DELETE-ITEM-AT ((container simple-associative-container) &rest indexes)
  • Method ITERATE-KEY-VALUE ((container simple-associative-container) function)
  • Method ITEM-AT ((container associative-container) &rest indexes)
  • Method DELETE-ITEM-AT ((container associative-container) &rest indexes)
  • Method ITERATE-KEY-VALUE ((container contents-as-hashtable-mixin) function)
  • Method ITEM-AT! ((container associative-container) value &rest indexes)
  • Method PRINT-CONTAINER ((container associative-container) &optional (stream *standard-output*))
  • Method PRINT-CONTAINER ((container stable-associative-container) &optional (stream *standard-output*))
  • Method ITEM-AT ((container alist-container) &rest indexes)
  • Method ITEM-AT-1 ((container alist-container) index)
  • Method ITEM-AT-1! ((container alist-container) value index)
  • Method ITEM-AT! ((container alist-container) value &rest indexes)
  • Method DELETE-ITEM-AT ((container alist-container) &rest indexes)
  • Method ITERATE-NODES ((container alist-container) function)
  • Method ITERATE-KEYS ((container alist-container) function)
  • Method REVERSE-FIND ((container alist-container) value &key (test (test container)))
  • Method EMPTY! ((container alist-container))
  • Method ITERATE-KEY-VALUE ((container alist-container) function)
  • Method SORT-KEYS ((container alist-container) sorter &key key)
  • Method SORT-ELEMENTS ((container alist-container) sorter &key key)
  • Class KEYED-ASSOCIATIVE-CONTAINER  (ASSOCIATIVE-CONTAINER, KEYED-CONTAINER-MIXIN)
    KEY-MAP   Accessor: KEY-MAP
    IN-ITEM-AT?   Reader: IN-ITEM-AT?
  • Method ITEM-AT ((container keyed-associative-container) &rest indexes)
  • Generic-Function KEY-EXISTS-P (container &rest indexes)
  • Method KEY-EXISTS-P ((container associative-container-mixin) &rest indexes)
  • Method ITERATE-KEY-VALUE ((container (eql nil)) fn)
  • Method ITERATABLE-P ((thing list))
  • Method ITERATE-ELEMENTS ((list null) fn)
  • Method ITERATE-NODES ((list null) fn)
  • Method ITERATE-ELEMENTS ((list list) fn)
  • Method ITERATE-NODES ((list list) fn)
  • Method COLLECT-ELEMENTS ((list list) &key filter transform)
  • Method ELEMENT-POSITION ((list list) element &key (key 'identity) (test 'eq))
  • Method EMPTY-P ((list list))
  • Method FIRST-ELEMENT ((list list))
  • Method (setf FIRST-ELEMENT) (value (list list))
  • Method LAST-ELEMENT ((list list))
  • Method (setf LAST-ELEMENT) (value (list list))
  • Method NTH-ELEMENT ((list list) (n integer))
  • Method SEARCH-FOR-MATCH ((list list) predicate &key (key 'identity))
  • Method FIND-ITEM ((list list) item)
  • Method SEARCH-FOR-ITEM ((list list) item &key test key)
  • Method SEARCH-FOR-ELEMENT ((list list) item &key (test nil) (key 'identity))
  • Method REDUCE-ELEMENTS ((container list) function &key (key 'identity) (initial-value nil initial-value-supplied-p) (start 0) end)
  • Method SOME-ITEM-P ((container list) (predicate function))
  • Method SOME-ELEMENT-P ((container list) predicate)
  • Method EVERY-ITEM-P ((container list) (predicate function))
  • Method EVERY-ELEMENT-P ((container list) predicate)
  • Method ITERATE-ELEMENTS ((vector vector) fn)
  • Method ITERATE-NODES ((vector vector) fn)
  • Method ITERATABLE-P ((thing vector))
  • Method COLLECT-ELEMENTS ((vector vector) &key filter transform)
  • Method EMPTY-P ((vector vector))
  • Method FIRST-ELEMENT ((vector vector))
  • Method (setf FIRST-ELEMENT) (value (vector vector))
  • Method LAST-ELEMENT ((vector vector))
  • Method (setf LAST-ELEMENT) (value (vector vector))
  • Method SEARCH-FOR-MATCH ((vector vector) predicate &key (key 'identity))
  • Method SOME-ITEM-P ((container vector) (predicate function))
  • Method SOME-ELEMENT-P ((container vector) predicate)
  • Method EVERY-ITEM-P ((container vector) (predicate function))
  • Method EVERY-ELEMENT-P ((container vector) predicate)
  • Method SORT-ELEMENTS ((container sequence) sorter &key (key 'identity))
  • Method NTH-ELEMENT ((container vector) (index number))
  • Method ITERATE-ELEMENTS ((array array) fn)
  • Method ITERATE-NODES ((array array) fn)
  • Method ITERATABLE-P ((thing array))
  • Method COLLECT-ELEMENTS ((array array) &key filter transform)
  • Method FIRST-ELEMENT ((array array))
  • Method (setf FIRST-ELEMENT) (value (array array))
  • Method LAST-ELEMENT ((array array))
  • Method (setf LAST-ELEMENT) (value (array array))
  • Method SEARCH-FOR-MATCH ((array array) predicate &key (key 'identity))
  • Method SOME-ELEMENT-P ((array array) predicate)
  • Method EVERY-ELEMENT-P ((array array) predicate)
  • Method NTH-ELEMENT ((container array) (index number))
  • Method ITEM-AT ((array array) &rest indexes)
  • Method ITEM-AT! ((array array) value &rest indexes)
  • Method ITERATABLE-P ((thing hash-table))
  • Method ITERATE-ELEMENTS ((hash-table hash-table) fn)
  • Method ITERATE-NODES ((hash-table hash-table) fn)
  • Method COLLECT-ELEMENTS ((hash-table hash-table) &key filter transform)
  • Method COLLECT-KEYS ((hash-table hash-table) &key filter (transform 'identity))
  • Method ITERATE-KEY-VALUE ((hash-table hash-table) fn)
  • Method EMPTY! ((hash-table hash-table))
  • Method EMPTY-P ((hash-table hash-table))
  • Method ITEM-AT ((hash-table hash-table) &rest indexes)
  • Method ITEM-AT! ((value t) (hash-table hash-table) &rest indexes)
  • Method ITEM-AT-1 ((hash-table hash-table) index)
  • Method ITEM-AT-1! ((hash-table hash-table) (value t) index)
  • Method PRINT-CONTAINER ((hash-table hash-table) &optional (stream *standard-output*))
  • Method ITEM-AT ((container list) &rest indexes)
  • Method ITEM-AT-1 ((container list) index)
  • Method ITERATE-KEY-VALUE ((container list) function)
  • Method COLLECT-KEY-VALUE ((container list) &rest args &key filter transform)
  • Method COLLECT-KEYS ((container list) &key filter (transform 'identity))
    If the list begins with an atom, then it is treated as a property list; otherwise, it is treated as an associative-list.
  • Method DELETE-ITEM-AT ((container list) &rest indexes)
  • Method ITEM-AT ((container vector-container-mixin) &rest indices)
  • Method ITEM-AT! ((container vector-container-mixin) value &rest indices)
  • Method NTH-ELEMENT ((container vector-container-mixin) (index integer))
  • Method FIRST-ELEMENT ((container vector-container-mixin))
  • Method (setf FIRST-ELEMENT) (value (container vector-container-mixin))
  • Method LAST-ELEMENT ((v vector-container-mixin))
  • Method (setf LAST-ELEMENT) (value (v vector-container-mixin))
  • Class BOUNDED-VECTOR-CONTAINER  (BASIC-VECTOR-CONTAINER, CONCRETE-CONTAINER)
    No slots.
  • Class VECTOR-CONTAINER  (BASIC-VECTOR-CONTAINER, CONCRETE-CONTAINER)
    No slots.
  • Method DELETE-ITEM ((container vector-container) item)
  • Method DELETE-FIRST ((v vector-container))
  • Method DELETE-LAST ((v vector-container))
  • Class FLEXIBLE-VECTOR-CONTAINER  (VECTOR-CONTAINER)
    No slots.
  • Method ITEM-AT! ((container flexible-vector-container) value &rest indices)
  • Class QUAD-TREE  (INITIAL-CONTENTS-MIXIN, CLASSIFIED-CONTAINER-MIXIN, FINDABLE-CONTAINER-MIXIN, ITERATABLE-CONTAINER-MIXIN, CONTAINER-USES-NODES-MIXIN, ROOTED-TREE-CONTAINER, CONCRETE-CONTAINER)
    SIZE   Accessor: SIZE
  • Method MAKE-NODE-FOR-CONTAINER ((tree quad-tree) (item t) &key)
  • Generic-Function NOTIFY-ELEMENT-OF-CHILD-STATUS (element status)
    This is called to allow the element to know its status as a child. Useful for quad tree elements, where an element's position relative to its parent could be relevant to the element. Status is one of: :TOP-LEFT, :TOP-RIGHT, :BOTTOM-LEFT, :BOTTOM-RIGHT or :ROOT
  • Method NOTIFY-ELEMENT-OF-CHILD-STATUS ((element t) (status t))
  • Method NOTIFY-ELEMENT-OF-CHILD-STATUS ((element t) (status t))
  • Method NOTIFY-ELEMENT-OF-CHILD-STATUS ((element t) (status t))
  • Method INSERT-ITEM ((tree quad-tree) (item quad-tree-node))
  • Method EMPTY-P ((tree quad-tree))
  • Method EMPTY! ((tree quad-tree))
  • Method FIND-ITEM ((tree quad-tree) (item quad-tree-node))
  • Class HEAP-CONTAINER  (SORTED-CONTAINER-MIXIN, VECTOR-CONTAINER, CONTAINER-USES-NODES-MIXIN)
    No slots.
  • Method MAKE-NODE-FOR-CONTAINER ((heap heap-container) (element t) &key)
  • Method BIGGEST-ITEM ((heap heap-container))
  • Method DELETE-BIGGEST-ITEM ((heap heap-container))
  • Method DELETE-ITEM ((heap heap-container) (node heap-node))
  • Method INSERT-ITEM ((heap heap-container) (node heap-node))
  • Class K-BEST-HEAP-CONTAINER  (BOUNDED-CONTAINER-MIXIN, HEAP-CONTAINER)
    Stores the k *best* values where *best* is defined by sorter. This means that the item at the top of the heap is the *worst* item. So if you want the best items to be the largest items, make sure sorter is '<'.
    K   Accessor: K-BEST-NUMBER
  • Method INSERT-ITEM ((heap k-best-heap-container) item)
  • Method ITERATE-ELEMENTS ((container filtered-container-mixin) fn)
  • Method COLLECT-ELEMENTS ((container filtered-container-mixin) &key filter transform)
  • Method ITERATE-KEY-VALUE ((container filtered-container-mixin) fn)
  • Method GRAFT-NODES (node1 node2)
  • Method FIND-SET (item)
  • Class UNION-FIND-CONTAINER  (CONTENTS-AS-HASHTABLE-MIXIN)
    No slots.
  • Method REPRESENTATIVE ((container union-find-container) item)
  • Method REPRESENTATIVE-NODE ((container union-find-container) item)
  • Class PACKAGE-CONTAINER  (ITERATABLE-CONTAINER-MIXIN, ABSTRACT-CONTAINER)
    PACKAGES   Reader: PACKAGES
    EXPORTED-SYMBOLS-ONLY-P   Accessor: EXPORTED-SYMBOLS-ONLY-P
    PRESENT-SYMBOLS-ONLY-P   Accessor: PRESENT-SYMBOLS-ONLY-P
  • Method (setf PACKAGES) ((value symbol) (container package-container))
  • Method (setf PACKAGES) ((value cons) (container package-container))
  • Method ITERATE-ELEMENTS ((container package-container) fn)
  • Generic-Function MAKE-ITERATOR (iteratee &rest args &key iterator-class &allow-other-keys)
  • Generic-Function FINISH (iterator)
    Tell Lisp that you are done with this iterator. Further calls to current-element, etc. will have unspecified behavior and may cause an error.
  • Generic-Function MOVE-P (iterator direction)
  • Generic-Function MOVE (iterator direction)
  • Generic-Function CURRENT-ELEMENT (thing)
  • Generic-Function CURRENT-ELEMENT-P (iterator)
  • Generic-Function ITERATE-FORWARD (iterator function)
  • Generic-Function MOVE-FORWARD (iterator)
  • Condition BASIC-ITERATOR-CONDITION
  • Condition NO-CURRENT-ELEMENT-ERROR  (BASIC-ITERATOR-CONDITION, ERROR)
  • Method FINISH ((iterator abstract-generator))
  • Method MOVE-P ((iterator abstract-generator) direction)
  • Class FORWARD-ITERATOR  (BASIC-ITERATOR, ITERATABLE-CONTAINER-MIXIN)
    No slots.
  • Method ITERATE-CONTAINER ((iterator forward-iterator) fn)
  • Method ITERATE-NODES ((iterator forward-iterator) fn)
  • Method EMPTY-P ((object forward-iterator))
  • Method CURRENT-ELEMENT-P ((iterator basic-iterator))
  • Method MOVE ((iterator basic-iterator) direction)
  • Function MOVE-FORWARD-P (iterator)
  • Method MOVE-FORWARD ((iterator forward-iterator))
  • Method ITERATE-FORWARD ((iterator basic-iterator) function)
  • Method CURRENT-ELEMENT ((iterator transforming-iterator-mixin))
  • Method MOVE ((iterator transforming-iterator-mixin) direction)
  • Method MOVE ((iterator basic-filtered-iterator-mixin) (direction (eql :forward)))
  • Class FILTERED-ITERATOR-MIXIN  (BASIC-FILTERED-ITERATOR-MIXIN)
    FILTER   Reader: FILTER
  • Class UNIQUE-VALUE-ITERATOR-MIXIN  (BASIC-FILTERED-ITERATOR-MIXIN, TEST-CONTAINER-MIXIN)
    VISITED   Reader: VISITED
  • Method MOVE-P ((iterator circular-iterator-mixin) (direction (eql :forward)))
  • Class LIST-ITERATOR  (FORWARD-ITERATOR)
    No slots.
  • Method MOVE ((iterator list-iterator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT ((iterator list-iterator))
  • Method MOVE-P ((iterator list-iterator) (direction (eql :forward)))
  • Method MOVE ((iterator array-iterator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT-P ((iterator array-iterator))
  • Method CURRENT-ELEMENT ((iterator array-iterator))
  • Method MOVE-P ((iterator array-iterator) (direction (eql :forward)))
  • Method MAKE-ITERATOR (iteratee &rest args &key (iterator-class nil) &allow-other-keys)
  • Function MAKE-GENERATOR (&rest args &key (generator-class nil) &allow-other-keys)
  • Method MOVE ((iterator arithmetic-sequence-generator) (direction (eql :forward)))
  • Method MOVE-P ((iterator arithmetic-sequence-generator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT ((iterator arithmetic-sequence-generator))
  • Method MOVE-P ((iterator finite-arithmetic-sequence-generator) (direction (eql :forward)))
  • Function MAP-CONTAINERS (fn &rest containers)
  • Function COLLECT-CONTAINERS (fn &rest containers)
  • Macro WITH-ITERATOR ((var source &rest args) &body body)
  • Method FINISH ((iterator basic-stream-iterator))
  • Method MOVE ((iterator file-iterator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT ((iterator file-iterator))
  • Method CURRENT-ELEMENT-P ((iterator file-iterator))
  • Method MOVE-P ((iterator file-iterator) (direction (eql :forward)))
  • Method MOVE ((iterator file-line-iterator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT ((iterator file-line-iterator))
  • Method CURRENT-ELEMENT-P ((iterator file-line-iterator))
  • Method MOVE-P ((iterator file-line-iterator) (direction (eql :forward)))
  • Method MOVE ((iterator file-form-iterator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT ((iterator file-form-iterator))
  • Method CURRENT-ELEMENT-P ((iterator file-form-iterator))
  • Method MOVE-P ((iterator file-form-iterator) (direction (eql :forward)))
  • Method MOVE ((iterator delimited-iterator) (direction (eql :forward)))
  • Method CURRENT-ELEMENT ((iterator delimited-iterator))
  • Method CURRENT-ELEMENT-P ((iterator delimited-iterator))
  • Method MOVE-P ((iterator delimited-iterator) (direction (eql :forward)))
  • Function FIND-EXISTING-SUBCLASS (superclass superclasses)
    Look through all the sub-classes of superclass and see if any of them descend from every class in superclasses.
  • Function FIND-OR-CREATE-CLASS (root classes)
    Try to find a class which is a subclass of root and all of the other `classes` as well. If no such class exists, then it will be created and returned.
  • Generic-Function INCLUDE-CLASS-DEPENDENCIES (class-type dynamic-class class-list &rest parameters)
  • Generic-Function EXISTING-SUBCLASS (class-type class-list)
  • Function PARAMETER->DYNAMIC-CLASS (table parameter)
  • Function (setf PARAMETER->DYNAMIC-CLASS) (value table parameter)
  • Function ADD-PARAMETER->DYNAMIC-CLASS (class-type parameter &rest super-classes)
  • Function EMPTY-ADD-PARAMETER->DYNAMIC-CLASS (class-type)
  • Function EMPTY-ALL-ADD-PARAMETER->DYNAMIC-CLASS
  • Method INCLUDE-CLASS-DEPENDENCIES ((class-type (eql nil)) dynamic-class class-list &rest parameters)
  • Method EXISTING-SUBCLASS ((class-type (eql nil)) (class-list t))
  • Function DETERMINE-DYNAMIC-CLASS (class-type dynamic-class &rest parameters)
  • Method MAKE-CONTAINER ((classes list) &rest args)
  • Method EXISTING-SUBCLASS ((class-type (eql :iterator)) class-list)
  • Method EXISTING-SUBCLASS ((class-type (eql :generator)) class-list)
  • Method INCLUDE-CLASS-DEPENDENCIES ((class-type (eql :iterator)) dynamic-class class-list &rest parameters &key treat-contents-as &allow-other-keys)

Also exports

  • METABANG.UTILITIES:TOTAL-SIZE
  • METABANG.UTILITIES:ELEMENT
  • METABANG.UTILITIES:ELEMENT-TYPE
  • METABANG.UTILITIES:FILTER
  • METABANG.UTILITIES:PARENT
  • METABANG.UTILITIES:ARGMIN
  • METABANG.UTILITIES:BEST-ITEM
  • METABANG.UTILITIES:SIZE
  • METABANG.UTILITIES:ARGMAX
  • METABANG.UTILITIES:ROOT