The doplus Reference Manual

This is the doplus Reference Manual, version 1.1.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sat Dec 03 21:20:33 2022 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 doplus

DO+ (doplus) is a high-level, extensible iteration construct for Common Lisp with a reasonably simple implementation, which in particular does not use a code walker.

Author

Alessio Stalla <>

License

GPLv3

Version

1.1.0

Dependency

parse-declarations-1.0 (system).

Source

doplus.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


3.1.1 doplus/doplus.asd

Source

doplus.asd.

Parent Component

doplus (system).

ASDF Systems

doplus.


3.1.2 doplus/packages.lisp

Source

doplus.asd.

Parent Component

doplus (system).

Packages

doplus.


3.1.3 doplus/destructuring.lisp

Dependency

packages.lisp (file).

Source

doplus.asd.

Parent Component

doplus (system).

Internals

3.1.4 doplus/doplus.lisp

Dependency

destructuring.lisp (file).

Source

doplus.asd.

Parent Component

doplus (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 doplus

Source

packages.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


5.1.1 Special variables

Special Variable: *iteration-variable*
Package

doplus.

Source

doplus.lisp.


5.1.2 Macros

Macro: accumulating-to (vars &key initially by finally)

Specifies an accumulation clause. Refer to the manual for details.

Package

doplus.

Source

doplus.lisp.

Macro: accumulating-to-and-returning (vars &rest args &key initially by finally)

Same as accumulating-into, but also returns the value of each <vars> at the end of the loop.

Package

doplus.

Source

doplus.lisp.

Macro: across (vector &rest args &key index start end by)

Synonym for in-vector.

Package

doplus.

Source

doplus.lisp.

Macro: being (form &key then)

Assigns to the iteration variable a value computed by evaluating FORM on each iteration, including the first. Optionally, the variable can be updated evaluating a differen form (the value of the ‘then’ parameter). Examples: (for x (being (random))), (for y (being ’quiet :then (if (> x 0.5) ’angry ’quiet))).

Package

doplus.

Source

doplus.lisp.

Macro: collect (value &key into)

Collects a value into an accumulator. If no accumulator is provided, the default one for the current do+ loop is used.

Package

doplus.

Source

doplus.lisp.

Macro: collecting-into (vars &rest args &key initially by finally)

Synonym for accumulating-to.

Package

doplus.

Source

doplus.lisp.

Macro: collecting-into-and-returning (vars &rest args &key initially by finally)

Same as collecting-into, but also returns the value of each <vars> at the end of the loop.

Package

doplus.

Source

doplus.lisp.

Macro: counting (var)

Counts the number of iterations, starting from 0.

Package

doplus.

Source

doplus.lisp.

Macro: defclause (name arglist &body body)

Same as cl:defmacro, but additionally records <name> in *clauses* as a known clause macro.

Package

doplus.

Source

doplus.lisp.

Macro: do+ (&body body)

High-level, extensible iteration construct. Refer to the manual for syntax and semantics.

Package

doplus.

Source

doplus.lisp.

Macro: finally (&rest forms)

Evaluates <form> after the last iteration, before returning a value.

Package

doplus.

Source

doplus.lisp.

Macro: finding (var condition)

Same as FOR, but perhaps nicer to read when used in conjunction with macros like MAXIMIZING.

Package

doplus.

Source

doplus.lisp.

Macro: for (var-or-vars iteration)

General iteration clause. Its actual behaviour is controlled by ITERATION, a macro form that FOR expands with *ITERATION-VARIABLE* bound to VAR. Example: in (for x (in ’(1 2 3))), IN is a macro that expands into clauses that make use of *ITERATION-VARIABLE*, which is bound to the symbol X in the example. For certain iteration macros, VAR can be a lambda-list as well, in which case destructuring is applied. Example: (for (x &optional y) (in-list ’((1 2) (3)))).

Package

doplus.

Source

doplus.lisp.

Macro: from (initial-value &key to by while using)

Iterates from a given initial value to an optional maximum. Every iteration increments/decrements the value applying the <using> function (by default +) to the previous value and <by> (by default 1 or -1, depending on whether to >= from or not). Similarly, the <while> function is used to determine if <to> has been reached or surpassed. <while> is a function of two arguments, the current value and the value of <to>, and as soon as it returns false, the loop is terminated. <while> defaults to a function that returns true only if <to> has been specified and, letting cur be the current value, (<= (min to from) cur (max to from)).

Package

doplus.

Source

doplus.lisp.

Macro: generating (var iteration)

Lazy version of FOR. The user must call UPDATE or TRY-UPDATE in the body of the DO+ form in order to compute new values for the variable(s). Initialization, instead, is *always* performed eagerly.

Package

doplus.

Source

doplus.lisp.

Macro: hash-entries-of (hash-table)

Iterates over the entries of a hash table. The iteration variables must be specified as (key value), for example: (for (lemma definitions) (hash-entries-of the-english-vocabulary)).

Package

doplus.

Source

doplus.lisp.

Macro: in (seq &rest args &key &allow-other-keys)

Iterates over a sequence. IN must be used in combination with FOR, GENERATING and similar macros (those that bind *ITERATION-VARIABLE*). In implementations with extensible sequences (currently ABCL and SBCL), native sequence iterators are used, and all sequence types are supported, not just lists and vectors. In other implementations, an iterator specialized for lists or vectors is used depending on the type of sequence. All ‘args‘ are passed down to make-sequence-iterator (see the extensible sequences API paper for details [Rhodes2007]). IN can perform destructuring.

Package

doplus.

Source

doplus.lisp.

Macro: in-list (list &key by rest)

Like IN, but specialized for lists. Successive lists are obtained by calling the function BY (which by default is #’CDR) on the previous list. REST, if specified, is the variable holding the remaining elements to be processed; REST initially is bound to the entire list, then to successive lists obtained by funcalling BY.

Package

doplus.

Source

doplus.lisp.

Macro: in-vector (vector &key index start end by)

Loops across a vector. INDEX is bound to the index of the current element in the vector. The vector is traversed starting from index START (0 by default) to index END (the end of the vector if not specified); the index is incremented by BY (1 by default) on each iteration.

Package

doplus.

Source

doplus.lisp.

Macro: initially (&rest forms)

Evaluates <form> before the first iteration.

Package

doplus.

Source

doplus.lisp.

Macro: list-tails (list &key by)

Loops over the successive tails of a list, checking for the end of the list as if by ATOM. Can perform destructuring.

Package

doplus.

Source

doplus.lisp.

Macro: maximizing (form &key test saving in)

Synonym for optimizing.

Package

doplus.

Source

doplus.lisp.

Macro: minimizing (form &key test saving in)

Same as optimizing but with < as the default test.

Package

doplus.

Source

doplus.lisp.

Macro: optimizing (form &key test saving in)

Finds the optimum value of an expression across the iteration. Refer to the manual for details.

Package

doplus.

Source

doplus.lisp.

Macro: options (&rest args &key name atomic-updates)
Package

doplus.

Source

doplus.lisp.

Macro: previous (expr)

On every iteration, the for-variable is set to the value <expr> had at the end of the previous iteration (initially NIL).

Package

doplus.

Source

doplus.lisp.

Macro: returning (&rest forms)

Returns each form in <forms> as the value of the do+ form when the loop ends. If multiple forms are specified, by one or more RETURNING clauses, multiple values are returned, in the order the corresponding forms appear lexically. If one of the <forms> is (cl:values ...), then each value will be returned as if the values were spelled as direct arguments of the RETURNING form.

Package

doplus.

Source

doplus.lisp.

Macro: skip (&optional loop-name)

Skips the current iteration. Refers to the current loop or, if loop-name is specified, to the closest surrounding loop with that name.

Package

doplus.

Source

doplus.lisp.

Macro: stop-when (condition)

Synonym for until.

Package

doplus.

Source

doplus.lisp.

Macro: sum (value &key to)

Syntactic sugar for collect, intended to be used when the accumulator computes a sum.

Package

doplus.

Source

doplus.lisp.

Macro: summing-to (vars &optional result-processor)

Specifies an accumulation strategy with 0 as the default value and + as the accumulator function.

Package

doplus.

Source

doplus.lisp.

Macro: summing-to-and-returning (vars &optional result-processor)

Same as summing-to, but also returns the value of each <vars> at the end of the loop.

Package

doplus.

Source

doplus.lisp.

Macro: symbols-in (package-or-packages &rest symbol-types)

Iterates over the symbols in one or more packages. Symbol-types follows the specification of cl:with-package-iterator.

Package

doplus.

Source

doplus.lisp.

Macro: terminate (&optional loop-name return-value)

Immediately terminates the loop. Refers to the current loop or, if loop-name is specified and non-NIL, to the closest surrounding loop with that name. Can optionally specify a return value for the loop, which, if provided, will override the loop’s ordinary return value.

Package

doplus.

Source

doplus.lisp.

Macro: to (final-value &key from by while using)

Variation over from.

Package

doplus.

Source

doplus.lisp.

Macro: try-update (var &key on-error)

Tries to update the generator named <var> as by UPDATE. If the loop would be terminated as a result of the update operation, it is not terminated.

Any errors occurring during the update are ignored by default; however, it is possible to provide a function to be invoked in case of error to determine what to do. This is the value of the <on-error> parameter, which, if provided, must be a function of two arguments: the first is the value to be returned as the result of the try-update form if the error is suppressed; the second is the condition object itself, which can be resignaled. Calling TERMINATE inside the function, if it is defined lexically inside the DO+ body, will regularly terminate the loop.

Package

doplus.

Source

doplus.lisp.

Macro: update (var)

Updates the generator named <var>, calculating new value(s) for its variable(s) and evaluating its pre and post conditions, terminating the loop if they fail. If successful, the update returns the value of <var>.

Package

doplus.

Source

doplus.lisp.

Macro: with (&rest bindings)

Establishes bindings which are in effect for the whole loop.

Package

doplus.

Source

doplus.lisp.


5.1.3 Ordinary functions

Function: make-binding (var &key default)
Package

doplus.

Source

doplus.lisp.

Function: make-epilogue (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-finalization (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-initialization (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-iteration (&key bindings initializations steps preconditions postconditions)

General iteration clause generator.

Package

doplus.

Source

doplus.lisp.

Function: make-prologue (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-result (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-simple-iteration (&key var init step precondition postcondition)

Specialized iteration clause generator, where the iteration clause refers to a single variable, possibly with an initial value, step form, precondition, or postcondition.

Package

doplus.

Source

doplus.lisp.

Function: make-step (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-termination (&key condition)
Package

doplus.

Source

doplus.lisp.


5.1.4 Structures

Structure: options
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: map
Package

common-lisp.

Readers

options-map.

Writers

(setf options-map).


5.2 Internals


5.2.1 Special variables

Special Variable: *clauses*

A list of known symbols that name clause macros, useful for introspection and documentation purposes.

Package

doplus.

Source

doplus.lisp.


5.2.2 Macros

Macro: declaring (thing)

Causes the emission of a (declare <thing>) form in the declaration section of the loop.

Package

doplus.

Source

doplus.lisp.

Macro: do+/internal (doplus-env &body body)
Package

doplus.

Source

doplus.lisp.

Macro: until (condition)

Specifies a termination clause for the loop. When, at the beginning of an iteration, the clause evaluates to true, the loop stops.

Package

doplus.

Source

doplus.lisp.

Macro: while (condition)

Same as (until (not <condition>)).

Package

doplus.

Source

doplus.lisp.

Macro: with-atomic-updates ((&rest variables) &body body)
Package

doplus.

Source

doplus.lisp.

Macro: with-atomic-updates* ((&rest variables) binding-form &body body)
Package

doplus.

Source

doplus.lisp.

Macro: with-doplus-body (env &body body)
Package

doplus.

Source

doplus.lisp.

Macro: without-atomic-updates ((&rest variables) &body body)
Package

doplus.

Source

doplus.lisp.


5.2.3 Ordinary functions

Function: %make-binding (&key var default default-provided?)
Package

doplus.

Source

doplus.lisp.

Reader: accumulator-function (instance)
Writer: (setf accumulator-function) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

function.

Function: accumulator-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: accumulator-var (instance)
Writer: (setf accumulator-var) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

var.

Reader: binding-default (instance)
Writer: (setf binding-default) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

default.

Reader: binding-default-provided? (instance)
Writer: (setf binding-default-provided?) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

default-provided?.

Function: binding-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: binding-var (instance)
Writer: (setf binding-var) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

var.

Function: copy-accumulator (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-binding (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-declaration (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-doplus-env (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-epilogue (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-finalization (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-generator (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-initialization (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-options (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-prologue (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-result (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-step (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-termination (instance)
Package

doplus.

Source

doplus.lisp.

Function: copy-wrapper (instance)
Package

doplus.

Source

doplus.lisp.

Reader: declaration-form (instance)
Writer: (setf declaration-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: declaration-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: doplus-env-accumulators (instance)
Writer: (setf doplus-env-accumulators) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

accumulators.

Reader: doplus-env-default-collect-var (instance)
Writer: (setf doplus-env-default-collect-var) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

default-collect-var.

Reader: doplus-env-generators (instance)
Writer: (setf doplus-env-generators) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

generators.

Reader: doplus-env-loop-name (instance)
Writer: (setf doplus-env-loop-name) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

loop-name.

Function: doplus-env-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: doplus-env-parent (instance)
Writer: (setf doplus-env-parent) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

parent.

Reader: doplus-env-skip-label (instance)
Writer: (setf doplus-env-skip-label) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

skip-label.

Reader: doplus-env-terminate-label (instance)
Writer: (setf doplus-env-terminate-label) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

terminate-label.

Function: ensure-list (obj)

(if (listp obj) obj (list obj))

Package

doplus.

Source

doplus.lisp.

Reader: epilogue-form (instance)
Writer: (setf epilogue-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: epilogue-p (object)
Package

doplus.

Source

doplus.lisp.

Function: expand-with-simple-destructuring (form env)

Expand ‘form’ in ‘env’ as an iteration form that assigns to ‘*iteration-variable*’ destructuring as by ‘destructuring-bind’.

Package

doplus.

Source

doplus.lisp.

Function: extract-variables (lambda-list)
Package

doplus.

Source

destructuring.lisp.

Reader: finalization-form (instance)
Writer: (setf finalization-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: finalization-p (object)
Package

doplus.

Source

doplus.lisp.

Function: find-generator (name env)
Package

doplus.

Source

doplus.lisp.

Function: find-loop-in-env (name env)
Package

doplus.

Source

doplus.lisp.

Reader: generator-clauses (instance)
Writer: (setf generator-clauses) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

clauses.

Reader: generator-name (instance)
Writer: (setf generator-name) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

name.

Function: generator-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: initialization-form (instance)
Writer: (setf initialization-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: initialization-p (object)
Package

doplus.

Source

doplus.lisp.

Function: make-accumulator (&key var function)
Package

doplus.

Source

doplus.lisp.

Function: make-declaration (&key form)
Package

doplus.

Source

doplus.lisp.

Function: make-destructuring-form (lambda-list expression)
Package

doplus.

Source

destructuring.lisp.

Function: make-doplus-env (&key loop-name skip-label terminate-label default-collect-var accumulators generators parent)
Package

doplus.

Source

doplus.lisp.

Function: make-generator (&key name clauses)
Package

doplus.

Source

doplus.lisp.

Function: make-options (&key map)
Package

doplus.

Source

doplus.lisp.

Function: make-wrapper (&key function)
Package

doplus.

Source

doplus.lisp.

Reader: options-map (instance)
Writer: (setf options-map) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

map.

Function: options-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: prologue-form (instance)
Writer: (setf prologue-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: prologue-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: result-form (instance)
Writer: (setf result-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: result-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: step-form (instance)
Writer: (setf step-form) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

form.

Function: step-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: termination-condition (instance)
Writer: (setf termination-condition) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

condition.

Function: termination-p (object)
Package

doplus.

Source

doplus.lisp.

Reader: wrapper-function (instance)
Writer: (setf wrapper-function) (instance)
Package

doplus.

Source

doplus.lisp.

Target Slot

function.

Function: wrapper-p (object)
Package

doplus.

Source

doplus.lisp.


5.2.4 Structures

Structure: accumulator
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: var
Readers

accumulator-var.

Writers

(setf accumulator-var).

Slot: function
Package

common-lisp.

Readers

accumulator-function.

Writers

(setf accumulator-function).

Structure: binding
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: var
Readers

binding-var.

Writers

(setf binding-var).

Slot: default
Readers

binding-default.

Writers

(setf binding-default).

Slot: default-provided?
Readers

binding-default-provided?.

Writers

(setf binding-default-provided?).

Structure: declaration
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

declaration-form.

Writers

(setf declaration-form).

Structure: doplus-env
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: loop-name
Readers

doplus-env-loop-name.

Writers

(setf doplus-env-loop-name).

Slot: skip-label
Readers

doplus-env-skip-label.

Writers

(setf doplus-env-skip-label).

Slot: terminate-label
Readers

doplus-env-terminate-label.

Writers

(setf doplus-env-terminate-label).

Slot: default-collect-var
Readers

doplus-env-default-collect-var.

Writers

(setf doplus-env-default-collect-var).

Slot: accumulators
Readers

doplus-env-accumulators.

Writers

(setf doplus-env-accumulators).

Slot: generators
Readers

doplus-env-generators.

Writers

(setf doplus-env-generators).

Slot: parent
Readers

doplus-env-parent.

Writers

(setf doplus-env-parent).

Structure: epilogue
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

epilogue-form.

Writers

(setf epilogue-form).

Structure: finalization
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

finalization-form.

Writers

(setf finalization-form).

Structure: generator
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: name
Readers

generator-name.

Writers

(setf generator-name).

Slot: clauses
Readers

generator-clauses.

Writers

(setf generator-clauses).

Structure: initialization
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

initialization-form.

Writers

(setf initialization-form).

Structure: prologue
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

prologue-form.

Writers

(setf prologue-form).

Structure: result
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

result-form.

Writers

(setf result-form).

Structure: step
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: form
Readers

step-form.

Writers

(setf step-form).

Structure: termination
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: condition
Package

common-lisp.

Readers

termination-condition.

Writers

(setf termination-condition).

Structure: wrapper
Package

doplus.

Source

doplus.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: function
Package

common-lisp.

Readers

wrapper-function.

Writers

(setf wrapper-function).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   O   P   R   S   T   U   W  
Index Entry  Section

%
%make-binding: Private ordinary functions

(
(setf accumulator-function): Private ordinary functions
(setf accumulator-var): Private ordinary functions
(setf binding-default): Private ordinary functions
(setf binding-default-provided?): Private ordinary functions
(setf binding-var): Private ordinary functions
(setf declaration-form): Private ordinary functions
(setf doplus-env-accumulators): Private ordinary functions
(setf doplus-env-default-collect-var): Private ordinary functions
(setf doplus-env-generators): Private ordinary functions
(setf doplus-env-loop-name): Private ordinary functions
(setf doplus-env-parent): Private ordinary functions
(setf doplus-env-skip-label): Private ordinary functions
(setf doplus-env-terminate-label): Private ordinary functions
(setf epilogue-form): Private ordinary functions
(setf finalization-form): Private ordinary functions
(setf generator-clauses): Private ordinary functions
(setf generator-name): Private ordinary functions
(setf initialization-form): Private ordinary functions
(setf options-map): Private ordinary functions
(setf prologue-form): Private ordinary functions
(setf result-form): Private ordinary functions
(setf step-form): Private ordinary functions
(setf termination-condition): Private ordinary functions
(setf wrapper-function): Private ordinary functions

A
accumulating-to: Public macros
accumulating-to-and-returning: Public macros
accumulator-function: Private ordinary functions
accumulator-p: Private ordinary functions
accumulator-var: Private ordinary functions
across: Public macros

B
being: Public macros
binding-default: Private ordinary functions
binding-default-provided?: Private ordinary functions
binding-p: Private ordinary functions
binding-var: Private ordinary functions

C
collect: Public macros
collecting-into: Public macros
collecting-into-and-returning: Public macros
copy-accumulator: Private ordinary functions
copy-binding: Private ordinary functions
copy-declaration: Private ordinary functions
copy-doplus-env: Private ordinary functions
copy-epilogue: Private ordinary functions
copy-finalization: Private ordinary functions
copy-generator: Private ordinary functions
copy-initialization: Private ordinary functions
copy-options: Private ordinary functions
copy-prologue: Private ordinary functions
copy-result: Private ordinary functions
copy-step: Private ordinary functions
copy-termination: Private ordinary functions
copy-wrapper: Private ordinary functions
counting: Public macros

D
declaration-form: Private ordinary functions
declaration-p: Private ordinary functions
declaring: Private macros
defclause: Public macros
do+: Public macros
do+/internal: Private macros
doplus-env-accumulators: Private ordinary functions
doplus-env-default-collect-var: Private ordinary functions
doplus-env-generators: Private ordinary functions
doplus-env-loop-name: Private ordinary functions
doplus-env-p: Private ordinary functions
doplus-env-parent: Private ordinary functions
doplus-env-skip-label: Private ordinary functions
doplus-env-terminate-label: Private ordinary functions

E
ensure-list: Private ordinary functions
epilogue-form: Private ordinary functions
epilogue-p: Private ordinary functions
expand-with-simple-destructuring: Private ordinary functions
extract-variables: Private ordinary functions

F
finalization-form: Private ordinary functions
finalization-p: Private ordinary functions
finally: Public macros
find-generator: Private ordinary functions
find-loop-in-env: Private ordinary functions
finding: Public macros
for: Public macros
from: Public macros
Function, %make-binding: Private ordinary functions
Function, (setf accumulator-function): Private ordinary functions
Function, (setf accumulator-var): Private ordinary functions
Function, (setf binding-default): Private ordinary functions
Function, (setf binding-default-provided?): Private ordinary functions
Function, (setf binding-var): Private ordinary functions
Function, (setf declaration-form): Private ordinary functions
Function, (setf doplus-env-accumulators): Private ordinary functions
Function, (setf doplus-env-default-collect-var): Private ordinary functions
Function, (setf doplus-env-generators): Private ordinary functions
Function, (setf doplus-env-loop-name): Private ordinary functions
Function, (setf doplus-env-parent): Private ordinary functions
Function, (setf doplus-env-skip-label): Private ordinary functions
Function, (setf doplus-env-terminate-label): Private ordinary functions
Function, (setf epilogue-form): Private ordinary functions
Function, (setf finalization-form): Private ordinary functions
Function, (setf generator-clauses): Private ordinary functions
Function, (setf generator-name): Private ordinary functions
Function, (setf initialization-form): Private ordinary functions
Function, (setf options-map): Private ordinary functions
Function, (setf prologue-form): Private ordinary functions
Function, (setf result-form): Private ordinary functions
Function, (setf step-form): Private ordinary functions
Function, (setf termination-condition): Private ordinary functions
Function, (setf wrapper-function): Private ordinary functions
Function, accumulator-function: Private ordinary functions
Function, accumulator-p: Private ordinary functions
Function, accumulator-var: Private ordinary functions
Function, binding-default: Private ordinary functions
Function, binding-default-provided?: Private ordinary functions
Function, binding-p: Private ordinary functions
Function, binding-var: Private ordinary functions
Function, copy-accumulator: Private ordinary functions
Function, copy-binding: Private ordinary functions
Function, copy-declaration: Private ordinary functions
Function, copy-doplus-env: Private ordinary functions
Function, copy-epilogue: Private ordinary functions
Function, copy-finalization: Private ordinary functions
Function, copy-generator: Private ordinary functions
Function, copy-initialization: Private ordinary functions
Function, copy-options: Private ordinary functions
Function, copy-prologue: Private ordinary functions
Function, copy-result: Private ordinary functions
Function, copy-step: Private ordinary functions
Function, copy-termination: Private ordinary functions
Function, copy-wrapper: Private ordinary functions
Function, declaration-form: Private ordinary functions
Function, declaration-p: Private ordinary functions
Function, doplus-env-accumulators: Private ordinary functions
Function, doplus-env-default-collect-var: Private ordinary functions
Function, doplus-env-generators: Private ordinary functions
Function, doplus-env-loop-name: Private ordinary functions
Function, doplus-env-p: Private ordinary functions
Function, doplus-env-parent: Private ordinary functions
Function, doplus-env-skip-label: Private ordinary functions
Function, doplus-env-terminate-label: Private ordinary functions
Function, ensure-list: Private ordinary functions
Function, epilogue-form: Private ordinary functions
Function, epilogue-p: Private ordinary functions
Function, expand-with-simple-destructuring: Private ordinary functions
Function, extract-variables: Private ordinary functions
Function, finalization-form: Private ordinary functions
Function, finalization-p: Private ordinary functions
Function, find-generator: Private ordinary functions
Function, find-loop-in-env: Private ordinary functions
Function, generator-clauses: Private ordinary functions
Function, generator-name: Private ordinary functions
Function, generator-p: Private ordinary functions
Function, initialization-form: Private ordinary functions
Function, initialization-p: Private ordinary functions
Function, make-accumulator: Private ordinary functions
Function, make-binding: Public ordinary functions
Function, make-declaration: Private ordinary functions
Function, make-destructuring-form: Private ordinary functions
Function, make-doplus-env: Private ordinary functions
Function, make-epilogue: Public ordinary functions
Function, make-finalization: Public ordinary functions
Function, make-generator: Private ordinary functions
Function, make-initialization: Public ordinary functions
Function, make-iteration: Public ordinary functions
Function, make-options: Private ordinary functions
Function, make-prologue: Public ordinary functions
Function, make-result: Public ordinary functions
Function, make-simple-iteration: Public ordinary functions
Function, make-step: Public ordinary functions
Function, make-termination: Public ordinary functions
Function, make-wrapper: Private ordinary functions
Function, options-map: Private ordinary functions
Function, options-p: Private ordinary functions
Function, prologue-form: Private ordinary functions
Function, prologue-p: Private ordinary functions
Function, result-form: Private ordinary functions
Function, result-p: Private ordinary functions
Function, step-form: Private ordinary functions
Function, step-p: Private ordinary functions
Function, termination-condition: Private ordinary functions
Function, termination-p: Private ordinary functions
Function, wrapper-function: Private ordinary functions
Function, wrapper-p: Private ordinary functions

G
generating: Public macros
generator-clauses: Private ordinary functions
generator-name: Private ordinary functions
generator-p: Private ordinary functions

H
hash-entries-of: Public macros

I
in: Public macros
in-list: Public macros
in-vector: Public macros
initialization-form: Private ordinary functions
initialization-p: Private ordinary functions
initially: Public macros

L
list-tails: Public macros

M
Macro, accumulating-to: Public macros
Macro, accumulating-to-and-returning: Public macros
Macro, across: Public macros
Macro, being: Public macros
Macro, collect: Public macros
Macro, collecting-into: Public macros
Macro, collecting-into-and-returning: Public macros
Macro, counting: Public macros
Macro, declaring: Private macros
Macro, defclause: Public macros
Macro, do+: Public macros
Macro, do+/internal: Private macros
Macro, finally: Public macros
Macro, finding: Public macros
Macro, for: Public macros
Macro, from: Public macros
Macro, generating: Public macros
Macro, hash-entries-of: Public macros
Macro, in: Public macros
Macro, in-list: Public macros
Macro, in-vector: Public macros
Macro, initially: Public macros
Macro, list-tails: Public macros
Macro, maximizing: Public macros
Macro, minimizing: Public macros
Macro, optimizing: Public macros
Macro, options: Public macros
Macro, previous: Public macros
Macro, returning: Public macros
Macro, skip: Public macros
Macro, stop-when: Public macros
Macro, sum: Public macros
Macro, summing-to: Public macros
Macro, summing-to-and-returning: Public macros
Macro, symbols-in: Public macros
Macro, terminate: Public macros
Macro, to: Public macros
Macro, try-update: Public macros
Macro, until: Private macros
Macro, update: Public macros
Macro, while: Private macros
Macro, with: Public macros
Macro, with-atomic-updates: Private macros
Macro, with-atomic-updates*: Private macros
Macro, with-doplus-body: Private macros
Macro, without-atomic-updates: Private macros
make-accumulator: Private ordinary functions
make-binding: Public ordinary functions
make-declaration: Private ordinary functions
make-destructuring-form: Private ordinary functions
make-doplus-env: Private ordinary functions
make-epilogue: Public ordinary functions
make-finalization: Public ordinary functions
make-generator: Private ordinary functions
make-initialization: Public ordinary functions
make-iteration: Public ordinary functions
make-options: Private ordinary functions
make-prologue: Public ordinary functions
make-result: Public ordinary functions
make-simple-iteration: Public ordinary functions
make-step: Public ordinary functions
make-termination: Public ordinary functions
make-wrapper: Private ordinary functions
maximizing: Public macros
minimizing: Public macros

O
optimizing: Public macros
options: Public macros
options-map: Private ordinary functions
options-p: Private ordinary functions

P
previous: Public macros
prologue-form: Private ordinary functions
prologue-p: Private ordinary functions

R
result-form: Private ordinary functions
result-p: Private ordinary functions
returning: Public macros

S
skip: Public macros
step-form: Private ordinary functions
step-p: Private ordinary functions
stop-when: Public macros
sum: Public macros
summing-to: Public macros
summing-to-and-returning: Public macros
symbols-in: Public macros

T
terminate: Public macros
termination-condition: Private ordinary functions
termination-p: Private ordinary functions
to: Public macros
try-update: Public macros

U
until: Private macros
update: Public macros

W
while: Private macros
with: Public macros
with-atomic-updates: Private macros
with-atomic-updates*: Private macros
with-doplus-body: Private macros
without-atomic-updates: Private macros
wrapper-function: Private ordinary functions
wrapper-p: Private ordinary functions


A.3 Variables

Jump to:   *  
A   C   D   F   G   L   M   N   P   S   T   V  
Index Entry  Section

*
*clauses*: Private special variables
*iteration-variable*: Public special variables

A
accumulators: Private structures

C
clauses: Private structures
condition: Private structures

D
default: Private structures
default-collect-var: Private structures
default-provided?: Private structures

F
form: Private structures
form: Private structures
form: Private structures
form: Private structures
form: Private structures
form: Private structures
form: Private structures
function: Private structures
function: Private structures

G
generators: Private structures

L
loop-name: Private structures

M
map: Public structures

N
name: Private structures

P
parent: Private structures

S
skip-label: Private structures
Slot, accumulators: Private structures
Slot, clauses: Private structures
Slot, condition: Private structures
Slot, default: Private structures
Slot, default-collect-var: Private structures
Slot, default-provided?: Private structures
Slot, form: Private structures
Slot, form: Private structures
Slot, form: Private structures
Slot, form: Private structures
Slot, form: Private structures
Slot, form: Private structures
Slot, form: Private structures
Slot, function: Private structures
Slot, function: Private structures
Slot, generators: Private structures
Slot, loop-name: Private structures
Slot, map: Public structures
Slot, name: Private structures
Slot, parent: Private structures
Slot, skip-label: Private structures
Slot, terminate-label: Private structures
Slot, var: Private structures
Slot, var: Private structures
Special Variable, *clauses*: Private special variables
Special Variable, *iteration-variable*: Public special variables

T
terminate-label: Private structures

V
var: Private structures
var: Private structures


A.4 Data types

Jump to:   A   B   D   E   F   G   I   O   P   R   S   T   W  
Index Entry  Section

A
accumulator: Private structures

B
binding: Private structures

D
declaration: Private structures
destructuring.lisp: The doplus/destructuring․lisp file
doplus: The doplus system
doplus: The doplus package
doplus-env: Private structures
doplus.asd: The doplus/doplus․asd file
doplus.lisp: The doplus/doplus․lisp file

E
epilogue: Private structures

F
File, destructuring.lisp: The doplus/destructuring․lisp file
File, doplus.asd: The doplus/doplus․asd file
File, doplus.lisp: The doplus/doplus․lisp file
File, packages.lisp: The doplus/packages․lisp file
finalization: Private structures

G
generator: Private structures

I
initialization: Private structures

O
options: Public structures

P
Package, doplus: The doplus package
packages.lisp: The doplus/packages․lisp file
prologue: Private structures

R
result: Private structures

S
step: Private structures
Structure, accumulator: Private structures
Structure, binding: Private structures
Structure, declaration: Private structures
Structure, doplus-env: Private structures
Structure, epilogue: Private structures
Structure, finalization: Private structures
Structure, generator: Private structures
Structure, initialization: Private structures
Structure, options: Public structures
Structure, prologue: Private structures
Structure, result: Private structures
Structure, step: Private structures
Structure, termination: Private structures
Structure, wrapper: Private structures
System, doplus: The doplus system

T
termination: Private structures

W
wrapper: Private structures