Common Lisp Package: SERIES

README:

FUNCTION

Public

CATENATE (ITEMS1 ITEMS2 &REST MORE-ITEMS)

(catenate items1 items2 &rest more-items) Concatenates two or more series end to end.

CHOOSE (BOOLS &OPTIONAL (ITEMS NIL ITEMS-P))

(choose bools &optional (items bools)) Chooses the elements of ITEMS corresponding to non-null elements of BOOLS. If ITEMS is not given, then the non-null elements of BOOLS is returned

CHOOSE-IF (PRED ITEMS)

(choose-if pred items) Chooses the elements of ITEMS for which PRED is non-null.

CHUNK (M N &OPTIONAL (ITEMS NIL ITEMS-P))

(chunk m n items) Break up the input series ITEMS into (possibly overlapping) chunks of length M. The starting positions of successive chunks differ by N. The inputs M and N must both be positive integers. CHUNK produces M output series. The ith chunk consists of the ith elements of the M outputs. Suppose that the length of ITEMS is L. The length of each output is the floor of 1+(L-M)/N. The ith element of the kth output is the (i*n+k)th element of ITEMS (i and k counting from zero).

COLLECTING-FN (TYPE INITS FUNCTION &REST ARGS)

(collecting-fn type init function &rest series-inputs) Computes cumulative values by applying FUNCTION to the elements of ITEMS. TYPE specifies the type of values returned by FUNCTION. INIT is a function that returns the initial values for the series. The output, t1,..., tm, are computed as follows: (values t1[0] ... tm[0] = (multiple-value-call function (funcall init) s1[0] ... sn[0]) (values t1[j] ... tm[j] = (funcall function t1[j-1] ... tm[j-1] s1[j] ... sn[j]) where s1[j],...,sn[j] are the j'th elements of the n input series.

COTRUNCATE (&REST ITEMS-LIST)

(cotruncate &rest series) Truncates the inputs so that they are all no longer than the shortest one.

EXPAND (BOOLS ITEMS &OPTIONAL (DEFAULT NIL))

(expand bools items &optional (default nil)) The output contains the elements of the input series ITEMS spread out into the positions specified by the non-null elements in BOOLS---that is, ITEMS[j] is in the position occupied by the jth non-null element in BOOLS. The other positions in the output are occupied by DEFAULT. The output stops as soon as BOOLS runs out of elements or a non-null element in BOOLS is encountered for which there is no corresponding element in ITEMS.

LATCH (ITEMS &KEY (AFTER NIL) (BEFORE NIL) (PRE NIL PRE-P) (POST NIL POST-P))

(latch items &key after before pre post) The series returned by LATCH is the same as the input series ITEMS except that some of the elements are replaced by other values. LATCH acts like a LATCH electronic circuit component. Each input element causes the creation of a corresponding output element. After a specified number of non-null input elements have been encountered, the latch is triggered and the output mode is permanently changed. The :AFTER and :BEFORE arguments specify the latch point. The latch point is just after the :AFTER-th non-null element in ITEMS or just before the :BEFORE-th non-null element. If neither :AFTER nor :BEFORE is specified, an :AFTER of 1 is assumed. If both are specified, it is an error. If a :PRE is specified, every element prior to the latch point is replaced by this value. If a :POST is specified, every element after the latch point is replaced by this value. If neither is specified, a :POST of NIL is assumed.

MAKE-SERIES (ITEM &REST ITEM-LIST)

Creates a series of the items.

MAP-FN (TYPE FUNCTION &REST ARGS)

(map-fn type function &rest series-inputs) The higher-order function map-fn supports the general concept of mapping. The TYPE argument is a type specifier indicating the type of values returned by FUNCTION. The values construct can be used to indicate multiple types; however, TYPE cannot indicate zero values. If TYPE indicates m types , then map-fn returns m series T1, ..., Tm, where Ti has the type (series ). The argument FUNCTION is a function. The remaining arguments (if any) are all series.

MASK (MONOTONIC-INDICES)

(mask monotonic-indices) Creates a series containing T in the indicated positions and NIL elsewhere. The positions must be a strictly increasing series of non-negative integers.

MINGLE (ITEMS1 ITEMS2 COMPARATOR)

(mingle items1 items2 comparator) Merges two series into one, with the same elements and order as ITEMS1 and ITEMS2. The COMPARATOR must accept two arguments and return non-null if and only if its first argument is strictly less than its second argument (in some appropriate sense). At each step, the COMPARATOR is used to compare the current elements in the two series. If the current element from ITEMS2 is strictly less than the current element from ITEMS1, the current element is removed from ITEMS2 and transferred to the output. Otherwise, the next output element comes from ITEMS1.

POSITIONS (BOOLS)

(positions bools) Returns a series of the positions of non-null elements in bools. Positions are counted from 0.

PREVIOUS (ITEMS &OPTIONAL (DEFAULT NIL) (AMOUNT 1))

(previous items &optional (default nil) (amount 1)) The series returned by PREVIOUS is the same as the input series ITEMS except that it is shifted to the right by the positive integer AMOUNT. The shifting is done by inserting AMOUNT copies of DEFAULT before ITEMS and discarding AMOUNT elements from the end of ITEMS.

SCAN (SEQ-TYPE &OPTIONAL (SEQ NIL SEQ-P))

(scan [type] sequence) SCAN returns a series containing the elements of sequence in order. The type argument is a type specifier indicating the type of sequence to be scanned; it must be a (not necessarily proper) subtype of sequence. If type is omitted, it defaults to list.

SCAN-ALIST (ALIST &OPTIONAL (TEST #'EQL))

(scan-alist alist &optional (test #'eql)) Creates two series containing the keys and values in an alist.

SCAN-FILE (NAME &OPTIONAL (READER #'READ))

(scan-file file-name &optional (reader #'read) SCAN-FILE opens the file named by the string FILE-NAME and applies the function READER to it repeatedly until the end of the file is reached. READER must accept the standard input function arguments input-stream, eof-error-p, and eof-value as its arguments. (For instance, reader can be read, read-preserving-white-space, read-line, or read-char.) If omitted, READER defaults to READ. SCAN-FILE returns a series of the values returned by READER, up to but not including the value returned when the end of the file is reached. The file is correctly closed, even if an abort occurs.

SCAN-FN (TYPE INIT STEP &OPTIONAL (TEST NIL TEST-P))

(scan-fn type init step &optional test) Enumerates a series. TYPE specifies the type of the value(s) returned by INIT and STEP. The elements are computed as follows: (values t1[0] ... tm[0]) = (funcall init) (values t1[j] ... tm[j]) = (funcall step t1[j-1] ... tm[j-1]) where t1, ..., tm are the output series. If TEST is not specified, the output is unbounded. If TEST is specified, the output is terminated when (funcall tests t1[j] ... tm[j]) is non-NIL. The elements that cause termination are not part of the output.

SCAN-FN-INCLUSIVE (TYPE INIT STEP TEST)

(scan-fn-inclusive type init step &optional test) Enumerates a series. TYPE specifies the type of the value(s) returned by INIT and STEP. The elements are computed as follows: (values t1[0] ... tm[0]) = (funcall init) (values t1[j] ... tm[j]) = (funcall step t1[j-1] ... tm[j-1]) where t1, ..., tm are the output series. If TEST is not specified, the output is unbounded. If TEST is specified, the output is terminated when (funcall tests t1[j] ... tm[j]) is non-NIL. The elements that cause termination are part of the output.

SCAN-HASH (TABLE)

(scan-hash table) Scans the entries of the hash table and returns two series containing the keys and their associated values. The first element of key series is the key of the first entry in the hash table, and the first element of the values series is the value of the first entry, and so on. The order of scanning the hash table is not specified.

SCAN-LISTS-OF-LISTS (TREE &OPTIONAL (TEST #'ATOM TEST-P))

(scan-lists-of-lists lists-of-lists &optional (leaf-test 'atom)) Creates a series of the nodes in a tree, in preorder order. LEAF-TEST returns non-NIL if a node is a leaf node.

SCAN-LISTS-OF-LISTS-FRINGE (TREE &OPTIONAL (TEST #'ATOM TEST-P))

(scan-lists-of-lists-fringe lists-of-lists &optional (leaf-test 'atom) Creates a series of the leaves of a tree, in preorder order. LEAF-TEST returns non-NIL if a node is a leaf node.

SCAN-MULTIPLE (TYPE SEQUENCE &REST SEQUENCES)

(scan-multiple type first-seq &rest more-sequences) Like several calls to SCAN, but scans multiple sequences in parallel efficiently.

SCAN-PLIST (PLIST)

(scan-plist plist) Creates two series containing the indicators and values in a plist.

SCAN-RANGE (&KEY (FROM 0) (BY 1) (UPTO NIL) (BELOW NIL) (DOWNTO NIL) (ABOVE NIL) (LENGTH NIL) (TYPE 'NUMBER))

(scan-range &key (:start 0) (:by 1) (:type 'number) :upto :below :downto :above :length) The function SCAN-RANGE returns a series of numbers starting with the :start argument (default integer 0) and counting up by the :by argument (default integer 1). The :type argument (default number) is a type specifier indicating the type of numbers in the series produced. The :type argument must be a (not necessarily proper) subtype of number. The :start and :by arguments must be of that type. One of the last five arguments may be used to specify the kind of end test to be used; these are called termination arguments. If :upto is specified, counting continues only so long as the numbers generated are less than or equal to :upto. If :below is specified, counting continues only so long as the numbers generated are less than :below. If :downto is specified, counting continues only so long as the numbers generated are greater than or equal to :downto. If :above is specified, counting continues only so long as the numbers generated are greater than :above. If :length is specified, it must be a non-negative integer and the output series has this length. If none of the termination arguments are specified, the output has unbounded length. If more than one termination argument is specified, it is an error.

SCAN-STREAM (NAME &OPTIONAL (READER #'READ))

(scan-stream stream &optional (reader #'read)) Creates a series of the forms in the stream STREAM. Similar to SCAN-FILE, except we read from an existing stream.

SCAN-SUBLISTS (LST)

(scan-sublists list) Creates a series of the sublists in a list. (SCAN-SUBLISTS '(A B C)) => #Z((A B C) (B C) (C))

SCAN-SYMBOLS (&OPTIONAL (PACKAGE NIL))

(scan-symbols (&optional (package *package*)) Creates a series of the symbols in PACKAGE (which defaults to *PACKAGE*).

SERIES (EXPR &REST EXPR-LIST)

(series arg &rest args) Creates an infinite series that endlessly repeats the given items in the order given.

SPLIT (ITEMS BOOLS &REST MORE-BOOLS)

(split items bools &rest more-bools) Partition the input series ITEMS between several outputs. If there are N test inputs following ITEMS, then there are N+1 outputs. Each input element is placed in exactly one output series, depending on the outcome of a sequence of tests. If the element ITEMS[j] fails the first K-1 tests and passes the kth test, it is put in the kth output. If ITEMS[j] fails every test, it is placed in the last output. In addition, all output stops as soon as any series input runs out of elements.

SPLIT-IF (ITEMS PRED &REST MORE-PRED)

(split-if items pred &rest more-pred) Partition the input series ITEMS between several outputs. If there are N test inputs following ITEMS, then there are N+1 outputs. Each input element is placed in exactly one output series, depending on the outcome of a sequence of tests. If the element ITEMS[j] fails the first K-1 predicate tests and passes the kth test, it is put in the kth output. If ITEMS[j] fails every test, it is placed in the last output. In addition, all output stops as soon as any series input runs out of elements.

SPREAD (GAPS ITEMS &OPTIONAL (DEFAULT NIL))

(spread gaps items &optional (default nil) SPREAD is quite similar to EXPAND, except instead of giving booleans on where to put the items, GAPS are specified which indicate how far apart the items should be. A gap of 0 means the items will be adjacent.

SUBSERIES (ITEMS START &OPTIONAL (BELOW NIL BELOW-P))

(subseries items start &optional below) SUBSERIES returns a series containing the elements of the input series ITEMS indexed by the non-negative integers from START up to, but not including, BELOW. If BELOW is omitted or greater than the length of ITEMS, the output goes all of the way to the end of ITEMS.

TO-ALTER (SERIES ALTER-FUNCTION &REST OTHER-INPUTS)

Specifies how to alter SERIES.

UNTIL (BOOLS ITEMS-1 &REST ITEMS-I)

(until bools items-1 &rest series-inputs) Returns ITEMS-I up to, but not including, the first non-null element of BOOLS.

UNTIL-IF (PRED ITEMS-1 &REST ITEMS-I)

(until-if pred items-1 &rest series-inputs) Returns ITEMS-i up to, but not including, the first element which satisfies PRED.

Undocumented

GENERATOR (S)

NEXT-OUT (GATHERER ITEM)

RESULT-OF (GATHERER)

Private

ALTER-FN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

CATENATE2 (ITEMS1 ITEMS2)

COLLECT-DECLARED (CATEGORY DECLS)

Given a list of DECLARE forms, concatenate all declarations of the same category, with DECLAREs and category removed

COMPUTE-OPTIMIZABLE-SERIES-FN (DEFINER NAME LAMBDA-LIST EXPR-LIST)

Defines a series function, see lambda-series.

COPY-FRAG (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-GENERATOR (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-SYM (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

DATA-SO-FAR (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DESTARRIFY (BASE BINDS DECLS LOCALDECLS PROLOGS FORMS &OPTIONAL (WRAPPER #'LIST) (WRAPPED-PROLOGS-P NIL))

Covert a BASE* form into a nested set of BASE forms

EVERY-NTH (M N ITEMS)

Returns a series of every Nth element of ITEMS, after skipping M elements.

EXTRACT-DECLARATIONS (FORMS)

Grab all the DECLARE expressions at the beginning of the list forms

GEN-FN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMAGE-BASE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMAGE-DATUM (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

IMAGE-FN (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

LITERAL-SERIES (SEQ)

MAKE-NULLABLE (TYP)

Make a type specifier of the form: (or FOO NULL)

N-GENSYMS (N &OPTIONAL (ROOT (SYMBOL-NAME 'G)))

Generate n uninterned symbols with basename root

NEVER (&REST STUFF)

Always returns NIL

NOVERLAP (N L1 L2)

Overlap l2 over the last n components of n1.

SCAN* (SEQ-TYPE SEQ)

Enumerates a series of the values in SEQ without checking for the end.

TYPE-OR-LIST-OF-TYPE (TYP)

Make a type specifier of the form: (or FOO (list FOO))

UNTIL-IF1 (PRED ITEMS OTHER-ITEMS)

Returns ITEMS up to, but not including, the first element which satisfies PRED.

UNTIL1 (BOOLS ITEMS)

Returns ITEMS up to, but not including, the first non-null element of BOOLS.

VARIABLE-P (THING)

Return T if thing is a non-keyword symbol different from T and NIL

Undocumented

*FRAGL-1 (STUFF)

+ARG (ARG FRAG)

+DFLOW (SOURCE DEST)

+FRAG (FRAG)

+RET (RET FRAG)

-ARG (ARG)

-DFLOW (SOURCE DEST)

-FRAG (FRAG)

-RET (RET)

2MAPAUX (FUN AUXS)

2MAPCAN (FUN ORIG)

2MAPCAR (FUN ORIG)

2MAPPROLOG (FUN PROLOGS)

3MAPAUX (FUN AUXS)

3MAPCAN (FUN ORIG)

3MAPCAR (FUN ORIG)

3MAPPROLOG (FUN PROLOGS)

A (CODE)

ABBREVIATED-MAP-FN-READER (STREAM SUBCHAR ARG)

ACTIVE-TERMINATOR-P (FRAG)

ADD-AUX (FRAG VAR TYP &OPTIONAL (VAL NIL VAL-P))

ADD-DUMMY-SOURCE-FRAG (FRAG)

ADD-LITERAL-AUX (FRAG VAR TYP VAL)

ADD-NONLITERAL-AUX (FRAG VAR TYP VAL)

ADD-PHYSICAL-INTERFACE (ARG)

ADD-PHYSICAL-OUT-INTERFACE (RET ALTER-PROP)

ADD-PROLOG (FRAG P)

ADD-WRAPPER (FRAG WRAP-FN &OPTIONAL (WHAT T))

ALL-NXTS (FRAG)

ALL-PRVS (FRAG)

SETFALTER-FN (NEW-VALUE INSTANCE)

ALTERABLE (STRUCTURE)

SETFALTERABLE (NEW-VALUE STRUCTURE)

ANNOTATE (CODE FRAG)

APPEND-PROLOG (FRAG P)

APPLY-FRAG (FRAG VALUES)

APPLY-LITERAL-FRAG (FRAG-AND-VALUES)

APPLY-PHYSICAL-FRAG (STUFF ARGS)

APPLY-WRAPPERS (WRPS CODE &OPTIONAL (TEST #'IDENTITY))

ARG-LIST (ARGS)

ARGS (STRUCTURE)

SETFARGS (NEW-VALUE STRUCTURE)

ARRAY-FILL-POINTER-OR-TOTAL-SIZE (SEQ)

ATOM-OR-CAR (X)

AUX (STRUCTURE)

SETFAUX (NEW-VALUE STRUCTURE)

AUX->PROLOG (AUXS)

AUX-INIT (AUX)

AUX-ORDERING (A B)

B (CODE)

B* (CODE)

BACK-PTRS (STRUCTURE)

SETFBACK-PTRS (NEW-VALUE STRUCTURE)

BASIC-COLLECT-FN (INITS FUNCTION &REST ARGS)

BASIC-COLLECT-LIST (ITEMS)

BASIC-DO-NEXT-IN (G)

BASIC-PROD-FORM->FRAG-BODY (FORMS INPUT-ALIST SERIES-OUTPUT-ALIST)

BASIC-SERIES-P (OBJECT)

BIND-LIST (ARGS SEQUENTIAL &AUX (PENDING NIL))

BODY (STRUCTURE)

SETFBODY (NEW-VALUE STRUCTURE)

BRANCHES-TO (LABEL TREE)

CANONICAL-TYPE (TYPE)

CAR-IMAGE-OF-NON-NULL-DATUM-TH (G DATUM)

CHECK-OFF-LINE-PORTS (FRAG VARS OFF-LINE-PORTS)

CHECK-TERMINATION (*GRAPH*)

CLEAN-CODE (AUX PROLOGS CODE)

CLEAN-CODE1 (SUSPICIOUS PROLOGS CODE)

CLEAN-LABS (FRAG STMTNS)

CLEAN-TAGBODY (EXPR)

CLEAN-TAGBODY-BODY (EXPR)

CLEAN-TAGBODY-DEADCODE (EXPR)

CLEAN-TAGBODY-REDUNDANCY (EXPR)

CODE (STRUCTURE)

SETFCODE (NEW-VALUE STRUCTURE)

CODIFY (FRAG)

CODIFY-1 (AUX PROLOGS CODE)

CODIFY-2 (AUX PROLOGS CODE)

COERCE-TO-TYPE (TYPE RET)

COERCE-TO-TYPES (TYPES FRAG)

COLLECT-DECLS (CATEGORY DECLS)

COLLECT-FN-OPT (WRAP-FN TYPE INITS FUNCTION &REST ARGS)

COLLECT-OTHER-DECLS (CATEGORY DECLS)

COMPILER-LET (BINDINGS &REST FORMS)

COMPILER-LET-TEMPLATE (FORM)

COMPUTE-BINDS-AND-DECLS (AUX)

COMPUTE-PROLOGING-MACFORM (NAME BODY-CODE)

COMPUTE-SERIES-FUNFORM (NAME ARGLIST DOC DCL BODY-CODE OPT-P)

COMPUTE-SERIES-MACFORM (NAME ARGLIST DOC DCL BODY-CODE BODY-FN TRIGGER LOCAL-P DISC-EXPR OPT-EXPR)

COMPUTE-SERIES-MACFORM-1 (NAME ARGLIST BODY-CODE BODY-FN TRIGGER LOCAL-P DISC-EXPR OPT-EXPR)

COMPUTE-SERIES-MACFORM-2 (NAME ARGLIST DOC BODY-CODE TRIGGER LOCAL-P DISC-EXPR OPT-EXPR UNOPT-EXPANSION)

COMPUTE-TOTAL-SIZE (DIMS)

CONTAINS-ANY (ITEMS THING)

CONTAINS-P (ITEM THING)

CONVERT-TO-ENUMERATOR (RET OFF-LINE-EXIT)

CONVERT-TO-REDUCER (ARG)

COPY-BASIC-SERIES (INSTANCE)

COPY-FOUNDATION-SERIES (INSTANCE)

COPY-FRAGMENT (FRAG)

COPY-IMAGE-SERIES (INSTANCE)

COPY-LIST-LAST (ORIG)

COPY-PTRS (SYM FRAG)

COUNT-ON-LINE (FRAG)

CURRENT-ALTER-INFO (STRUCTURE)

SETFCURRENT-ALTER-INFO (NEW-VALUE STRUCTURE)

SETFDATA-SO-FAR (NEW-VALUE INSTANCE)

DECLARIZE (WRAPPER DECLS LOCALDECLS PROLOGS FORMS WRAPPED-P &OPTIONAL (PROGNIZE-P T) (WRAPPED-PROLOGS-P NIL))

DECODE-DCLS (FORMS ALLOWED-DCLS)

DECODE-MULTIPLE-TYPES-ARG (TYPE N)

DECODE-SEQ-TYPE (TYPE)

DECODE-TYPE-ARG (TYPE &OPTIONAL (ALLOW-ZERO NIL))

DEFINE-OPTIMIZABLE-SERIES-FN (NAME LAMBDA-LIST EXPR-LIST)

DEFS-1 (NAME ARGLIST DOC BODY OPTIMIZER TRIGGER DISCRIMINATOR LOCAL-P)

DELETE-AUX (VAR AUXS)

DELETE-AUX-IF (P AUXS)

DELETE-AUX-IF-NOT (P AUXS)

DELETE-LAST-PROLOG (PROLOGS)

DELETE-PROLOG (VAR PROLOGS)

DELETE-RET (RET FRAG)

DELETE1A (ITEM LIST)

DESERIALIZE-TYPE (TYPE)

DESTARRIFY-1 (BASE BINDS DECLS LOCALDECLS PROLOGS FORMS &OPTIONAL (WRAPPER #'LIST) (PROGNIZE-P T) (WRAPPED-PROLOGS-P NIL))

DETANGLE2 (ARGS)

DISCONNECTED-SPLIT (*GRAPH*)

DO-ALTER-PROP (VALUE GEN)

DO-COERCION

DO-NEXT-IN (G AT-END &OPTIONAL (ALTER NIL ALTERP))

DO-NON-SERIES-DFLOW-SPLIT (RET ARG)

DO-OFF-LINE-SPLIT (RET ARG)

DO-SPLIT (ITEMS STUFF BOOLS-P)

DO-SPLITTING (*GRAPH*)

DO-SUBSTITUTION (&AUX CODE RET KILLABLE)

DYNAMIZE-VARS (VARS FORMS TEST)

E (CODE)

EL (CODE)

ELM (CODE)

EPILOG (STRUCTURE)

SETFEPILOG (NEW-VALUE STRUCTURE)

EPILOG-WRAPPER-P (W)

EQ-CAR (THING ITEM)

ERS (ID &REST ARGS)

EVAL-ON-FIRST-CYCLE (FRAG ARG-FRAG)

EX (CODE)

EXPAND-MACROLET (CODE)

F (CODE)

F->P-OFF-LINE (I FRAG NEW-OUT OUT-VALUES DONE FLAG)

F->P-ON-LINE (FRAG NEW-OUT OUT-VALUES DONE FLAG)

FBIND-LIST (ARGS)

FIND-ALTER-FORM (RET)

FIND-ALTER-FORMS (RET)

FIND-AUX (VAR AUXS)

FIND-GENSYMS (TREE &OPTIONAL (FOUND NIL))

FIND-INITIALIZERS (VARS-TO-INIT CODE)

FIND-ON-LINE (SYMS)

FIND-OUT-VARS (CODE)

FIND-PROLOG (VAR PROLOGS)

FIRST-AUX (AUXS)

FIRST-AUX-BLOCK (AUXS)

FIRST-PROLOG (PROLOGS)

FIRST-PROLOG-BLOCK (PROLOGS)

FLATTEN-AUX (AUXS)

FLATTEN-PROLOG (PROLOGS)

FORCEL (N LIST)

FOUNDATION-SERIES-P (OBJECT)

FRAG->LIST (FRAG)

FRAG->PHYSICAL (FRAG ACTUAL-ARGS &OPTIONAL (FORCE-PRECOMPUTE? NIL))

FRAG-FOR-COLLECTOR (COLLECTOR *ENV*)

FRAG-P (G1458)

FRAGIFY (CODE TYPE)

FRAGL-1 (STUFF)

FRAGL-2 (STUFF ARGS)

FUN (CODE)

FUNCALL-FRAG (FRAG &REST VALUES)

FUNCALL-PHYSICAL-FRAG (STUFF &REST ARGS)

GATHER-SANITIZE (COLLECTOR)

GATHERERIFY (FRAG)

GATHERING-1 (BINDER BINDIFIER RESULT-OP DECLS VAR-COLLECTOR-PAIRS *ENV* BODY)

GATHERLET-1 (BINDER BINDIFIER DECLS VAR-COLLECTOR-PAIRS *ENV* BODY)

GEN-BASE (STRUCTURE)

SETFGEN-BASE (NEW-VALUE STRUCTURE)

SETFGEN-FN (NEW-VALUE INSTANCE)

GEN-STATE (STRUCTURE)

SETFGEN-STATE (NEW-VALUE STRUCTURE)

GENERATOR-CHECK (FORM)

GENERATOR0 (S)

GRAPHIFY (CODE &OPTIONAL (RETURN-TYPE '*))

HANDLE-DFLOW (SOURCE HANDLE-THIS-DFLOW &OPTIONAL (KILL-DFLOW T))

HANDLE-FN-ARG (FRAG FUNCTION PARAMS)

HANDLE-FN-CALL (FRAG OUT-VARS FN IN-VARS &OPTIONAL (LAST? NIL))

HANDLE-NON-SERIES-STUFF (CODE &OPTIONAL (STATE NIL) (CHECK-SETQ NIL))

SETFIMAGE-BASE (NEW-VALUE INSTANCE)

SETFIMAGE-DATUM (NEW-VALUE INSTANCE)

SETFIMAGE-FN (NEW-VALUE INSTANCE)

IMAGE-OF-DATUM-TH (G DATUM)

IMAGE-OF-NON-NULL-DATUM-TH (G DATUM)

IMAGE-OF-WITH-DATUM (G DATUM)

IMAGE-SERIES-P (OBJECT)

IMPLICIT-EPILOG (FRAG)

IMPURE (STRUCTURE)

SETFIMPURE (NEW-VALUE STRUCTURE)

INIT-ELEM (TYPE)

INSERT-OFF-LINE-DUMMY-FRAG (RET ARGS)

INSTALL (&KEY (PKG *PACKAGE*) (MACRO T) (SHADOW T) (IMPLICIT-MAP NIL) (REMOVE NIL) (SHADOW-EXTENSIONS SHADOW))

ISOLATE-NON-SERIES (N CODE)

ITERATIVE-COPY-TREE (TREE)

KILL-DEAD-CODE

KILL-RET (RET)

LAB (CODE)

LAST-PROLOG-BLOCK (PROLOGS)

LIFT-OUT-VARS (CODE)

LIFTABLE-VAR-P (VAR)

LIST->FRAG (LIST)

LIST->FRAG1 (LIST)

LIST->SYM (LIST FRAG)

LIST-OF-NEXT (AT-END LIST-OF-GENERATORS)

LISTER (WRAPPED-P)

LISTER-P (EXPR)

LITERAL-FRAG (STUFF)

LOCALIZE (DECLS FORMS WRAPPED-P)

LOOP-WRAPPER-P (W)

M-&-R (CODE &OPTIONAL (*FN* NIL))

M-&-R1 (CODE)

M-&-R2 (CODE TEMPLATE)

MAKE-BASIC-SERIES (&KEY ((ALTER-FN DUM4520) NIL) ((GEN-FN DUM4521) NIL) ((DATA-SO-FAR DUM4522) NIL))

MAKE-FOUNDATION-SERIES (&KEY ((ALTER-FN DUM4484) NIL))

MAKE-FRAG (&KEY ((CODE DUM1459) ) ((MARKS DUM1460) 0) ((MUST-RUN DUM1461) NIL) ((ARGS DUM1462) NIL) ((RETS DUM1463) NIL) ((AUX DUM1464) NIL) ((ALTERABLE DUM1465) NIL) ((PROLOG DUM1466) NIL) ((BODY DUM1467) NIL) ((EPILOG DUM1468) NIL) ((WRAPPERS DUM1469) NIL) ((IMPURE DUM1470) NIL))

MAKE-GENERAL-SETQ (VARS VALUE)

MAKE-GENERATOR (&KEY ((GEN-STATE DUM4652) NIL) ((GEN-BASE DUM4653) NIL) ((CURRENT-ALTER-INFO DUM4654) NIL))

MAKE-IMAGE-SERIES (&KEY ((ALTER-FN DUM4568) NIL) ((IMAGE-FN DUM4569) NIL) ((IMAGE-BASE DUM4570) NIL) ((IMAGE-DATUM DUM4571) NIL))

MAKE-INPUTS-OFF-LINE (FRAG OFF-LINE-EXIT)

MAKE-OUTPUTS-OFF-LINE (FRAG)

MAKE-PORTS-OFF-LINE (FRAG OFF-LINE-EXIT)

MAKE-READ-ARG-COMPLETELY (ARG &OPTIONAL (CNT NIL))

MAKE-SET-FLAG-RATHER-THAN-TERMINATE (FRAG)

MAKE-SYM (&KEY ((BACK-PTRS DUM2125) (MAKE-ARRAY 2 INITIAL-ELEMENT NIL)) ((VAR DUM2126) NIL) ((SERIES-VAR-P DUM2127) NIL) ((OFF-LINE-SPOT DUM2128) NIL) ((OFF-LINE-EXIT DUM2129) NIL))

MAKE-TEST (AND-OF-ORS)

MAKEAUX (AUXLIST)

MAKEPROLOG (PROLOGLIST)

MAP-EXP (EXP VARS)

MAPAUX (FUN AUXS)

MAPAUXN (FUN AUXS)

MAPIT (TYPE FN ARGS)

MAPPROLOG (FUN PROLOGS)

MARK (MASK FRAG)

MARKED-P (MASK FRAG)

MARKS (STRUCTURE)

SETFMARKS (NEW-VALUE STRUCTURE)

MATCHING-SCAN-P (EXPR PRED)

MAYBE-DE-SERIES (FRAG &OPTIONAL (PROLOGIZE T))

MERGE-DECS (DECLS)

MERGE-FRAGS (FRAG1 FRAG2)

MERGE-PROLOGS (P1 P2)

MERGIFY (*GRAPH*)

MULTIPLE-VALUE-SETQ-OPT (VARS EXP)

MUST-BE-QUOTED (TYPE)

MUST-RUN (STRUCTURE)

SETFMUST-RUN (NEW-VALUE STRUCTURE)

MY-LAMBDA-MACRO (FORM)

MY-MACROEXPAND (ORIGINAL-CODE)

MY-MULTI-SETQ (VARS VALUE FORM)

MY-SETQ-MACRO (FORM)

N-INTEGER-VALUES (N)

N-INTEGERS (N)

NEW-VAR (ATOM)

NMAPAUX (FUN AUXS)

NMERGE (L1 L2)

NMERGE-1 (L1 L2)

NO (CALL)

NON-SERIES-DFLOW-SPLIT (*GRAPH*)

NON-SERIES-MERGE (RET-FRAG ARG-FRAG)

NON-SERIES-MERGE-LIST (&REST FRAGS)

NON-SERIES-P (FRAG)

NON-SERIES-SPLIT (*GRAPH*)

NORMALIZE-PAIR (P ALLOW-MULTIPLE-VARS)

NOT-CONTAINED (ITEMS &REST THINGS)

NOT-CONTAINED-TWICE (ITEMS &REST THINGS)

NOT-EXPR-LIKE-SPECIAL-FORM-P (SYM)

NSUBST-INLINE (NEW-LIST OLD LIST &OPTIONAL (SAVE-SPOT NIL))

NULLABLE-P (TYP)

OFF-LINE-EXIT (STRUCTURE)

SETFOFF-LINE-EXIT (NEW-VALUE STRUCTURE)

OFF-LINE-MERGE (RET-FRAG RET ARG-FRAG ARG)

OFF-LINE-SPLIT (*GRAPH*)

OFF-LINE-SPOT (STRUCTURE)

SETFOFF-LINE-SPOT (NEW-VALUE STRUCTURE)

ON-LINE-MERGE (*GRAPH*)

OPT-FRAGL (STUFF INPUTS)

OPTIMIZE-PRODUCING (OUTPUT-LIST INPUT-LIST BODY)

ORDER-NUM (FRAGS)

OUT-VALUE (RET ALTER-PROP FLAG-OFF-LINE?)

PASS-THROUGH-FRAG (RETS)

POLYAPPLY (FUN ARGS)

POLYCALL (FUN &REST ARGS)

POS (&REST BOOLS)

POS-IF (ITEM &REST FNS)

PRECOMPUTE-FRAG->PHYSICAL (FRAG ALTER-PROP-ALIST)

PREPROCESS-BODY (ARGLIST SERIES-VARS TYPE-ALIST IGNORE-VARS FORMS OUTS)

PROCESS-FN (CODE)

PROCESS-LET-FORMS (FORMS)

PROCESS-LET-SERIES-BODY (IGNORE-VARS FORMS ALIST)

PROCESS-LET-SERIES-PAIR (P TYPE-ALIST ALLOW-MULTIPLE-VARS)

PROCESS-TOP (CALL)

PRODUCES-OPTIMIZABLE-SERIES (ORIGINAL-CODE)

PROGNIZE (FORMS &OPTIONAL (PROGNIZE-P T))

PROLOG (STRUCTURE)

SETFPROLOG (NEW-VALUE STRUCTURE)

PROLOG-APPEND (PROLOGS L)

PROLOG-BRANCHES-TO (LABEL FRAG)

PROLOG-LENGTH (P)

PROLOGIZE (PROLOGS FORMS WRAPPED-PROLOGS-P WRAPPED-P)

PROMOTE-SERIES (SERIES)

PROPAGATE-TYPES (EXPR AUX &OPTIONAL (INPUT-INFO NIL))

PROTECT-FROM-SETQ (IN TYPE)

PUSHARG (ARG FRAG)

Q (CODE)

REAP-FRAG (FRAG)

REMOVE-INITIALIZERS (INITS CODE)

REMOVE-PROLOG-IF (P PROLOGS)

REORDER-FRAGS (FORM)

REPORT-ERROR (TYPE INFO)

RESET-MARKS (&OPTIONAL (VALUE 0))

RETIFY (CODE &OPTIONAL (TYPE T))

RETS (STRUCTURE)

SETFRETS (NEW-VALUE STRUCTURE)

RETUNS-LIST-P (EXPR)

ROOT (SYMBOL)

RRS (ID &REST ARGS)

S (CODE)

SCAN-FN-OPT (WRAP-FN INCLUSIVE-P TYPE INIT STEP &OPTIONAL (TEST NIL TEST-P))

SCAN-MULTI-OUT->SCAN-LIST-OUT (FN TYPE INIT STEP TEST)

SEGREGATE-AUX (P AUXS)

SERIES-COERCE (A)

SERIES-FRAG->PHYSICAL (FRAG ALTER-PROP-ALIST)

SERIES-P (X)

SERIES-READER (STREAM SUBCHAR ARG)

SERIES-VAR-P (STRUCTURE)

SETFSERIES-VAR-P (NEW-VALUE STRUCTURE)

SETQ-OPT (VAR EXP)

SETQ-P (THING)

SIMPLE-QUOTED-LAMBDA (FORM)

SIMPLE-QUOTED-LAMBDA-ARGUMENTS (FORM)

SIMPLE-QUOTED-LAMBDA-BODY (FORM)

SIMPLIFY-AUX (AUXS)

SOME-OTHER-TERMINATION (ARG)

SOME-SERIES-TYPE-P (TYPE)

SPLIT-AFTER (FRAG CROSSABLE)

SUBLIS-LIMITS (TREE)

SUBSTITUTE-IN-INPUT (RET ARG)

SUBSTITUTE-IN-OUTPUT (RET ARG)

SYM-P (G2124)

TRUEFY-TYPE (TYPE)

UNDEFINE-OPTIMIZABLE-SERIES-FN (NAME)

UNOPT-FRAGL (STUFF)

USE-USER-NAMES (AUX LOOP)

VALIDATE-PRODUCING (OUTPUT-LIST INPUT-LIST BODY)

VALUES-LISTS (N SERIES-OF-LISTS &OPTIONAL (ALTERERS NIL))

VALUES-OF-NEXT (AT-END LIST-OF-GENERATORS)

VAR (STRUCTURE)

SETFVAR (NEW-VALUE STRUCTURE)

VARS-OF (ARG)

WORSEN-PURITY (P1 P2)

WRAP-CODE (WRPS CODE &OPTIONAL (TEST #'IDENTITY))

WRAPPER-FUNCTION (W)

WRAPPER-TYPE (W)

WRAPPERS (STRUCTURE)

SETFWRAPPERS (NEW-VALUE STRUCTURE)

WRS (ID ALWAYS-REPORT-P &REST ARGS)

YES (CALL)

MACRO

Public

ALTER (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

Alters the values in DESTINATIONS to be ITEMS.

COLLECT (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect [type] series) Creates a sequence containing the elements of SERIES. The TYPE argument specifies the type of sequence to be created. This type must be a proper subtype of sequence. If omitted, TYPE defaults to LIST.

COLLECT-ALIST (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-alist keys values) Combines a series of keys and a series of values together into an alist.

COLLECT-AND (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-and bools) Computes the AND of the elements of BOOLS.

COLLECT-APPEND (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-append [type] items) Given a series of sequences, COLLECT-APPEND returns a new sequence by concatenating these sequences together in order. The TYPE is a type specifier indicating the type of sequence created and must be a proper subtype of SEQUENCE. If TYPE is omitted, it defaults to LIST. For example: (COLLECT-APPEND #Z((A B) NIL (C D))) => (A B C D)

COLLECT-FILE (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-file name items &optional (printer #'print) This creates a file named FILE-NAME and writes the elements of the series ITEMS into it using the function PRINTER. PRINTER must accept two inputs: an object and an output stream. (For instance, PRINTER can be PRINT, PRIN1, PRINC, PPRINT, WRITE-CHAR, WRITE-STRING, or WRITE-LINE.) If omitted, PRINTER defaults to PRINT. The value T is returned. The file is correctly closed, even if an abort occurs.

COLLECT-FIRST (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-first items &optional (default nil)) Returns the first element of the series ITEMS. If ITEMS has no elements, DEFAULT is returned.

COLLECT-FN (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-fn type init-function function &rest args) Computes a cumulative value by applying FUNCTION to the elements of ITEMS. INIT-FUNCTION specifies the initial value(s). Like COLLECTING-FN, but only the last element of each series is returned.

COLLECT-HASH (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-hash keys values :test :size :rehash-size :rehash-threshold) Combines a series of keys and a series of values together into a hash table. The keyword arguments specify the attributes of the hash table to be produced. They are used as arguments to MAKE-HASH-TABLE

COLLECT-IGNORE (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-ignore series) Like COLLECT, but any output that would have been returned is discarded. In particular, no results are consed at all.

COLLECT-LAST (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-last items &optional (default nil)) Returns the last element of the series ITEMS. If ITEMS has no elements, DEFAULT is returned.

COLLECT-LENGTH (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-length items) Returns the number of elements in ITEMS.

COLLECT-MAX (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-max numbers &optional (items numbers items-p) (default nil)) Returns the element of ITEMS that corresponds to the maximum element of NUMBERS. If ITEMS is omitted, then the maximum of NUMBERS itself is returned. The value DEFAULT is returned if either NUMBERS or ITEMS has zero length.

COLLECT-MIN (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-min numbers &optional (items numbers items-p) (default nil)) Returns the element of ITEMS that corresponds to the minimum element of NUMBERS. If ITEMS is omitted, then the minimum of NUMBERS itself is returned. The value DEFAULT is returned if either NUMBERS or ITEMS has zero length.

COLLECT-NCONC (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-nconc items) COLLECT-NCONC NCONCs the elements of the series LISTS together in order and returns the result. This is the same as COLLECT-APPEND except that the input must be a series of lists, the output is always a list, the concatenation is done rapidly by destructively modifying the input elements, and therefore the output shares all of its structure with the input elements.

COLLECT-NTH (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-nth n items &optional (default nil)) Returns the Nth element of the series ITEMS. If ITEMS has no Nth element, DEFAULT is returned.

COLLECT-OR (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-or bools) Computes the OR of the elements of BOOLS.

COLLECT-PLIST (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-plist indicators values) Combines a series of indicators and a series of values together into a plist.

COLLECT-PRODUCT (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-product numbers &optional (type 'number)) Computes the product of the elements in NUMBERS. TYPE specifies the type of product to be created.

COLLECT-STREAM (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

Prints the elements of ITEMS onto the stream NAME.

COLLECT-SUM (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(collect-sum numbers &optional (type 'number)) Computes the sum of the elements in NUMBERS. TYPE specifies the type of sum to be created.

ENCAPSULATED (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

Specifies an encapsulating form to be used with a scanner or collector.

ITERATE (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(iterate ({({var | ({var}*)} value)}*) {declaration}* {form}*) Applies BODY to each element of the series, like MAPPING, but results are discarded.

PRODUCING (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

(producing output-list input-list {declaration}* {form}* PRODUCING computes and returns a group of series and non-series outputs given a group of series and non-series inputs. The OUTPUT-LIST has the same syntax as the binding list of a LET. The names of the variables must be distinct from each other and from the names of the variables in the INPUT-LIST. If there are N variables in the OUTPUT-LIST, PRODUCING computes N outputs. There must be at least one output variable. The variables act as the names for the outputs and can be used in either of two ways. First, if an output variable has a value associated with it in the OUTPUT-LIST, then the variable is treated as holding a non-series value. The variable is initialized to the indicated value and can be used in any way desired in the body. The eventual output value is whatever value is in the variable when the execution of the body terminates. Second, if an output variable does not have a value associated with it in the OUTPUT-LIST, the variable is given as its value a gatherer that collects elements. The only valid way to use the variable in the body is in a call on NEXT-OUT. The output returned is a series containing these elements. If the body never terminates, this series is unbounded. The INPUT-LIST also has the same syntax as the binding list of a LET. The names of the variables must be distinct from each other and the names of the variables in the OUTPUT-LIST. The values can be series or non-series. If the value is not explicitly specified, it defaults to NIL. The variables act logically both as inputs and state variables and can be used in one of two ways. First, if an input variable is associated with a non-series value, then it is given this value before the evaluation of the body begins and can be used in any way desired in the body. Second, if an input variable is associated with a series, then the variable is given a generator corresponding to this series as its initial value. The only valid way to use the variable in the body is in a call on NEXT-IN.

TERMINATE-PRODUCING

Causes the containing call on producing to terminate.

Undocumented

FGATHER-NEXT (GATHERER ITEM)

FGATHER-RESULT (GATHERER)

FGATHERING (VAR-COLLECTOR-PAIRS &ENVIRONMENT *ENV* &BODY FORMS)

FGATHERLET (VAR-COLLECTOR-PAIRS &ENVIRONMENT *ENV* &BODY BODY)

GATHER-NEXT (GATHERER ITEM)

GATHER-RESULT (GATHERER)

GATHERER (COLLECTOR &ENVIRONMENT *ENV*)

GATHERING (VAR-COLLECTOR-PAIRS &ENVIRONMENT *ENV* &BODY FORMS)

GATHERLET (VAR-COLLECTOR-PAIRS &ENVIRONMENT *ENV* &BODY BODY)

MAPPING (&REST STUFF)

NEXT-IN (GENERATOR &REST ACTIONS)

Private

BIND-IF ((SYMBOL PREDICATE) THEN &OPTIONAL ELSE)

Binds the symbol to predicate and executes body only if predicate is non-nil.

BIND-IF* ((SYMBOL PREDICATE) THEN &BODY ELSE)

Binds the symbol to predicate and executes body only if predicate is non-nil.

DEFCONST-ONCE (NAME VALUE &OPTIONAL DOCUMENTATION)

Like `defconstant' except that if the variable already has a value, the old value is not clobbered.

FUNCALL (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

ITERATE-MAC (VAR-VALUE-LIST &REST BODY)

Applies BODY to each element of the series

LET (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

LET* (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

MULTIPLE-VALUE-BIND (&WHOLE CALL &REST STUFF &ENVIRONMENT *ENV*)

WHEN-BIND ((SYMBOL PREDICATE) &BODY BODY)

Binds the symbol to predicate and executes body only if predicate is non-nil.

Undocumented

#1M (FN &REST ARGS)

#2M (FN &REST ARGS)

#3M (FN &REST ARGS)

#4M (FN &REST ARGS)

#5M (FN &REST ARGS)

#M (FN &REST ARGS)

*FRAGL (&REST STUFF)

COERCE-MAYBE-FOLD (THING TYPE)

DEFINLINE (&REST ARGS)

DEFS (NAME ARGLIST DOC BODY &KEY OPTIMIZER TRIGGER DISCRIMINATOR)

DEFT (NAME HEAD REST)

DEFUN (NAME LAMBDA-LIST &ENVIRONMENT *ENV* &BODY BODY)

DELETE1 (THING LIST)

DOAUX ((V AUXS) &BODY BODY)

DOFRAGS ((VAR . MASK) &BODY BODY)

DOING-SPLITTING (&BODY BODY)

DOING-SPLITTING1 (&BODY BODY)

DOPROLOG ((V PROLOGS) &BODY BODY)

EFRAGL (A STUFF)

ENCAPSULATED-MACRO (ENCAPSULATING-FN SCANNER-OR-COLLECTOR)

EOPTIF (F1 F2)

EOPTIF-Q (F1 F2)

FR (S)

FRAG-WRAPPERS (F)

FRAGL (&REST STUFF)

FREE-OUT (S)

FUNCASE ((BINDS FUNEXPR) &REST CASES)

LIMITED-SCAN (TYPE UNOPT-TYPE-LIMIT OPT-TYPE-LIMIT UNOPT-LIMIT &OPTIONAL OPT-LIMIT)

LIST-SCAN (TYPE)

MAKE-PHYS (&KEY (GEN-FN NIL) (ALTER-FN NIL) (DATA-LIST T))

MAKE-TEMPLATE (HEAD REST)

MAPPING-MAC (VAR-VALUE-LIST &BODY BODY)

MULTIPLE-VALUE-POLYCALL (FUN VALS)

MULTIPLE-VALUE-SETF (PLACES VALS)

NON-OPT-PRODUCING (OUTPUT-LIST INPUT-LIST &BODY BODY)

NON-OPTQ (X)

NULL-SCAN (TYPE)

NXTS (S)

OPTIF (F1 F2)

OPTIF-Q (F1 F2)

OPTQ (X)

PRV (S)

SLET* (DEFS &BODY FORMS)

SLET1 (DEF &BODY FORMS)

STARTING-SERIES-EXPR (CALL BODY)

TOP-STARTING-SERIES-EXPR (CALL OPT NON-OPT)

VALUATE (&REST ARGS)

VARIABLE

Public

*LAST-SERIES-ERROR*

Info about error found most recently by SERIES.

*LAST-SERIES-LOOP*

Loop most recently created by SERIES.

*SERIES-EXPRESSION-CACHE*

Avoids multiple expansions

*SUPPRESS-SERIES-WARNINGS*

Suppress warnings when the restrictions are violated.

Private

*IN-SERIES-EXPR*

the topmost series expression

*NOT-STRAIGHT-LINE-CODE*

not-nil if nested in non-straight-line code

*SERIES-IMPLICIT-MAP*

T enables implicit mapping in optimized expressions

*TESTING-ERRORS*

Used only be the file of tests

END

used to force copying of frag lists

Undocumented

*LIFT-OUT-VARS-P*

*OPTIMIZE-SERIES-EXPRESSIONS*

*STANDARD-FUNCTION-READER*

/EVAL-ALL-TEMPLATE/

/EXPR-TEMPLATE/

CLASS

Private

Undocumented

BASIC-SERIES

FOUNDATION-SERIES

IMAGE-SERIES

CONSTANT

Private

/EXPR-LIKE-SPECIAL-FORMS/

special forms that can be treated like ordinary functions. e.g., they have the same template as expr-template.

/SERIES-FORMS/

Forms redefined by Series.

/SHORT-HAND-TYPES/

table 4.1 from CLTL

Undocumented

/ALLOWED-GENERIC-OPTS/

/EXT-CONFLICTS/

/FEXPRS-NOT-HANDLED/