lispdoc - results for do

(do varlist endlist &body body)
Function: DO ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* Iteration construct. Each Var is initialized in parallel to the value of the specified Init form. On subsequent iterations, the Vars are assigned the value of the Step form (if any) in parallel. The Test is evaluated before each evaluation of the body Forms. When the Test is true, the Exit-Forms are evaluated as a PROGN, with the result being the value of the DO. A block named NIL is established around the entire expansion, allowing RETURN to be used as an alternate exit mechanism.
Example:
(defun length3 (list)
  (do ((len 0 (+ len 1))
       (l list (rest l)))
      ((null l) len)))
Mentioned in:
CLtL2 - 26.11. Unconditional Execution
CLtL2 - 26.12.2. Destructuring
CLtL2 - 26.3. Parsing Loop Clauses
CLtL2 - 26.3.2. Kinds of Loop Clauses
CLtL2 - 26.5. Loop Constructs
CLtL2 - 26.6. Iteration Control
CLtL2 - 29.2. Changes in Terminology
CLtL2 - 3. Scope and Extent
CLtL2 - 7. Control Structure
CLtL2 - 7.1.2. Assignment
CLtL2 - 7.10.2. Rules Governing the Passing of Multiple Values
CLtL2 - 7.5. Establishing New Variable Bindings
CLtL2 - 7.7. Blocks and Exits
CLtL2 - 7.8. Iteration
CLtL2 - 7.8.2. General Iteration
CLtL2 - 7.8.3. Simple Iteration Constructs
CLtL2 - 7.8.4. Mapping
CLtL2 - 7.8.5. The ``Program Feature''
CLtL2 - A.3.1. Basic Restrictions
HyperSpec - Macro DO, DO
On Lisp - A Sample ATN
On Lisp - Applications for Macros
On Lisp - Avoiding Capture by Prior Evaluation
On Lisp - Avoiding Capture with Gensyms
On Lisp - Avoiding Capture with Packages
On Lisp - Conditional Evaluation
On Lisp - Defining Simple Macros
On Lisp - Extending Lisp
On Lisp - Functional Design
On Lisp - Macro Argument Capture
On Lisp - Macros as Programs
On Lisp - Need for Macros
On Lisp - Non-functional Expanders
On Lisp - Number of Evaluations
On Lisp - When Capture Occurs
On Lisp - When Nothing Else Will Do
PCL - a sample macro do primes
PCL - beyond simple macros
PCL - do
PCL - equals then iteration
PCL - local flow of control
PCL - looping
PCL - manipulating the lexical environment
PCL - plugging the leaks
PCL - the mighty loop
PCL - value accumulation
PCL - where to go next
Successful Lisp - chapter05
Successful Lisp - chapter32
Successful Lisp - closures
(do* varlist endlist &body body)
Function: DO* ({(Var [Init] [Step])}*) (Test Exit-Form*) Declaration* Form* Iteration construct. Each Var is initialized sequentially (like LET*) to the value of the specified Init form. On subsequent iterations, the Vars are sequentially assigned the value of the Step form (if any). The Test is evaluated before each evaluation of the body Forms. When the Test is true, the Exit-Forms are evaluated as a PROGN, with the result being the value of the DO. A block named NIL is established around the entire expansion, allowing RETURN to be used as an laternate exit mechanism.
 Mentioned in:
CLtL2 - 26.6. Iteration Control
CLtL2 - 7.5. Establishing New Variable Bindings
CLtL2 - 7.8. Iteration
CLtL2 - 7.8.2. General Iteration
On Lisp - Extending Lisp
PCL - the mighty loop
Successful Lisp - closures
d
 
 Mentioned in:
HyperSpec - D
(do-symbols (var &optional (package '*package*) result-form) &body body-decls)
Function: DO-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECLARATION}* {TAG | FORM}* Executes the FORMs at least once for each symbol accessible in the given PACKAGE with VAR bound to the current symbol.
Example:
(defun symbols->list (pkg external?)
  (let ((list nil))
    (if external?
        (do-external-symbols (s pkg)
          (push s list))
        (do-symbols (s pkg) (push s list)))
    list))
Mentioned in:
CLtL2 - 11.2. Package Names
CLtL2 - 11.7. Package System Functions and Variables
CLtL2 - 7.8.3. Simple Iteration Constructs
CLtL2 - 7.9. Structure Traversal and Side Effects
HyperSpec - Macro DO-SYMBOLS, DO-EXTERNAL-SYMBOLS, DO-ALL-SYMBOLS
On Lisp - Chapter _28
(do-all-symbols (var &optional result-form) &body body-decls)
Function: DO-ALL-SYMBOLS (VAR [RESULT-FORM]) {DECLARATION}* {TAG | FORM}* Executes the FORMs once for each symbol in every package with VAR bound to the current symbol.
 Mentioned in:
CLtL2 - 11.2. Package Names
CLtL2 - 11.7. Package System Functions and Variables
CLtL2 - 25.3. Debugging Tools
CLtL2 - 7.8.3. Simple Iteration Constructs
HyperSpec - Macro DO-SYMBOLS, DO-EXTERNAL-SYMBOLS, DO-ALL-SYMBOLS
(ed &optional x)
Function: Starts the editor (on a file or a function if named). Functions from the list *ED-FUNCTIONS* are called in order with X as an argument until one of them returns non-NIL; these functions are responsible for signalling a FILE-ERROR to indicate failure to perform an operation on the file system.
 Mentioned in:
CLtL2 - 11.2. Package Names
CLtL2 - 25.3. Debugging Tools
HyperSpec - Function ED
(cl-ppcre:do-scans
 (match-start match-end reg-starts reg-ends regex target-string &optional
  result-form &key start end)
 &body body &environment env)
Function: Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-START, MATCH-END, REG-STARTS, and REG-ENDS bound to the four return values of each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-SCANS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. BODY may start with declarations.
  
(cl-ppcre:do-matches
 (match-start match-end regex target-string &optional result-form &key start
  end)
 &body body)
Function: Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-START and MATCH-END bound to the start/end positions of each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-MATCHES; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. BODY may start with declarations.
  
(do-external-symbols (var &optional (package '*package*) result-form) &body
 body-decls)
Function: DO-EXTERNAL-SYMBOLS (VAR [PACKAGE [RESULT-FORM]]) {DECL}* {TAG | FORM}* Executes the FORMs once for each external symbol in the given PACKAGE with VAR bound to the current symbol.
Example:
(defun external-symbols (package)
  (let ((acc
         (make-array 100 :adjustable t
                     :fill-pointer 0)))
    (do-external-symbols (symbol package)
      (vector-push-extend symbol acc))
    acc))
Mentioned in:
CLtL2 - 11.2. Package Names
CLtL2 - 11.7. Package System Functions and Variables
CLtL2 - 7.8.3. Simple Iteration Constructs
HyperSpec - Macro DO-SYMBOLS, DO-EXTERNAL-SYMBOLS, DO-ALL-SYMBOLS
d:
 
 Mentioned in:
HyperSpec - 22.3.2.2 Tilde D: Decimal
(cl-ppcre:do-register-groups var-list
 (regex target-string &optional result-form &key start end sharedp) &body body)
Function: Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with the variables in VAR-LIST bound to the corresponding register groups for each match in turn, i.e. each variable is either bound to a string or to NIL. For each element of VAR-LIST which is NIL there's no binding to the corresponding register group. The number of variables in VAR-LIST must not be greater than the number of register groups. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-REGISTER-GROUPS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING. BODY may start with declarations.
  
(cl-ppcre:do-matches-as-strings
 (match-var regex target-string &optional result-form &key start end sharedp)
 &body body)
Function: Iterates over TARGET-STRING and tries to match REGEX as often as possible evaluating BODY with MATCH-VAR bound to the substring of TARGET-STRING corresponding to each match in turn. After the last match, returns RESULT-FORM if provided or NIL otherwise. An implicit block named NIL surrounds DO-MATCHES-AS-STRINGS; RETURN may be used to terminate the loop immediately. If REGEX matches an empty string the scan is continued one position behind this match. If SHAREDP is true, the substrings may share structure with TARGET-STRING. BODY may start with declarations.
  
odd
 
 Mentioned in:
HyperSpec - 3.5.1.6 Odd Number of Keyword Arguments
(oddp number)
Function: Is this integer odd?
 Mentioned in:
CLtL2 - 12.2. Predicates on Numbers
HyperSpec - Function EVENP, ODDP
On Lisp - Building Functions
On Lisp - Chapter _28
On Lisp - Common Lisp Evolves
On Lisp - Conditional Evaluation
On Lisp - Recursion on Cdrs
On Lisp - Recursion on Cdrs (Macros Returning Functions)
On Lisp - Recursion on Subtrees
On Lisp - Recursion on Subtrees (Macros Returning Functions)
PCL - numeric comparisons