Some suggestions: loop {(keyword exprs*)}* [Special form] loop* {(keyword exprs*)}* [Special form] [Insert your previous description here. Might want to add this comment:] There are seven sections to a loop: binding, declaration, initialization, top, test, bottom, and epilog (see: defloop). Ordering of expressions in individual clauses, or conditionalizer and conditionalized expression pairs within each section of the loop is unspecified. [I'd like this latter statement to appear, but I'm unsure of how much existing Maclisp code depends on the order that loops were built. Any hints Kelly?] *loop-keywords* [Variable] Contains a list of loop keywords that are currently defined. defloop keyword &key [Macro] :condition-if expr :condition-not expr :bind expr :declarations expr :initializer expr :top-expr expr :test-if expr :test-not expr :bottom-expr expr :epilog-exprs expr Any of these arguments may be supplied in one call to defloop, except for the following pairs, of which only one may be supplied: :condition-if :condition-not :top-expr :bottom-expr :test-if :test-not Each keyword argument should either be unsupplied, or a function which generates a list of expressions, declarations, let format binding lists, or test expressions as appropriate. The function will be passed the tail of the loop clause that it corresponds to. A loop is built from the following seven sections, shown here in example: (block ...local variable setup ...declarations ...initializing expressions (tagbody loop ...loop top expressions (if (...test expressions) (go epilog)) ...loop bottom expressions (go loop) epilog ) ...epilog expressions ) Each of the generated expressions of forms is placed into the appropriate part of the loop. A block is established around the body of the loop to allow a return from within it. A tagbody is established around the body of the loop, with the tags loop and epilog in the appropriate positions. A loop may contain any number of clauses, of which each may generate many expressions. These expressions are always destined to be placed in a particular section of the constructed loop. Order of expressions within sections is unspecified. [I think the following will handle conditionalizers fairly well, Ron] The :condition-if and :condition-not expressions should return a form which is used to test whether the "expr" section of the next clause of the loop is executed on this iteration. They test non-NIL and NIL respectively. Any single defloop clause will have only one expression that is executed each time through a loop. The conditionalizer expression wraps around this expression. The:bind expression should return a list of the form: ({var | (var expression)}* which is similar to the binding lists of let and let*. Serial or parallel binding is controlled by which of loop or loop* are called. The declare expression should return a list of appropriate declarations for this loop. The initializer expression is evaluated once before the loop is entered. Only one of :top-expr or :bottom-expr may be supplied in to defloop. This is an expression which is evaluated once each time through the loop, either before (top) or after (bottom) the loop's end test is executed. One of either :test-if or :test-not may be supplied. Flow of control exits the loop and enters the top of the epilog code when this expression returns an appropriate value. && TIMESROMANTERMINAL TIMESROMAN Ji†›= ‚ J \>;ňF \.‡WI×® €řzş