This is the adp Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Tue Jul 15 03:10:37 2025 GMT+0.
The main system appears first, followed by any subsystem dependency.
Modules are listed depth-first from the system components tree.
adp/srcadp (system).
package.lisp (file).
racket.lisp (file).
adp.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
adp/src/racket.lisppackage.lisp (file).
src (module).
defmacro (macro).
defun (macro).
function-lambda-list (function).
(setf function-lambda-list) (function).
make-load-form (method).
make-load-form (method).
defmacro-aux (macro).
defun-aux (macro).
parse-racket-arg (function).
parse-racket-args (function).
parse-racket-values (function).
racket-arg (class).
racket-args (class).
adp/src/adp.lispracket.lisp (file).
src (module).
define-adp-file (macro).
define-adp-system (macro).
element-form (function).
element-value (function).
export-content (generic function).
file-component (function).
file-elements (function).
operation-done-p (method).
operation-done-p (method).
operation-done-p (method).
perform (method).
perform (method).
perform (method).
perform (method).
perform (method).
*files* (special variable).
add-file (function).
adp-system (class).
destroy-files-container (function).
error-condition (reader method).
(setf error-condition) (writer method).
eval-error (condition).
eval-expression (function).
expression (reader method).
(setf expression) (writer method).
file (reader method).
(setf file) (writer method).
get-lisp-expressions-and-stream (function).
in-package-expr-p (function).
in-readtable-expr-p (function).
make-files-container (function).
reexport (function).
scribble-element (class).
scribble-file (class).
scribble-source-file (class).
with-lisp-expressions-and-stream (macro).
Packages are listed by definition order.
adpcommon-lisp.
define-adp-file (macro).
define-adp-system (macro).
defmacro (macro).
defun (macro).
element-form (function).
element-value (function).
export-content (generic function).
file-component (function).
file-elements (function).
function-lambda-list (function).
(setf function-lambda-list) (function).
*files* (special variable).
add-file (function).
adp-system (class).
defmacro-aux (macro).
defun-aux (macro).
destroy-files-container (function).
error-condition (generic reader).
(setf error-condition) (generic writer).
eval-error (condition).
eval-expression (function).
expression (generic reader).
(setf expression) (generic writer).
file (generic reader).
(setf file) (generic writer).
get-lisp-expressions-and-stream (function).
in-package-expr-p (function).
in-readtable-expr-p (function).
make-files-container (function).
parse-racket-arg (function).
parse-racket-args (function).
parse-racket-values (function).
racket-arg (class).
racket-args (class).
reexport (function).
scribble-element (class).
scribble-file (class).
scribble-source-file (class).
with-lisp-expressions-and-stream (macro).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Defines an adp file.
NAME must be a symbol denoting the class of a file.
The user will need to use a keyword with the same name to specify
the defined file in its documentation system.
TYPE denotes the extension of the file.
DEFAULT-READTABLE denotes the default readtable to use when loading
the scribble file. This can be used if the exporter defines some extension to scribble
like latex math mode.
Defines an adp system class.
NAME must be a symbol denoting the class of a system.
The user will need to use a keyword with the same name to specify
the defined class in its documentation system.
Same as ADP:DEFUN but arguments are not evaluated.
adp.
Racket-like version of DEFUN.
This macro has the following syntax:
(defun name racket-lambda-list [[declaration* | documentation]] form*)
racket-lambda-list ::= (arg*)
| (arg* . rest-symbol)
| (arg* &rest rest-symbol)
arg ::= symbol
| (symbol default-form [supplied-symbol])
| keyword symbol
| keyword (symbol default-form [supplied-symbol])
The following explanation was taken and modified from: https://docs.racket-lang.org/reference/lambda.html
Regarding the racket-lambda-list and considering only the first case of arg, DEFUN has one of the
following three forms:
- (arg*)
The function accepts as many non-keyword argument values as the number of symbols.
Each symbol is associated with an argument value by position.
- (arg* . rest-symbol)
- (arg* &rest rest-symbol)
The function accepts any number of non-keyword arguments greater or equal to the number of symbols.
When the function is applied, the symbols are associated with argument values by position,
and all leftover arguments are placed into a list that is associated to rest-symbol.
More generally, an arg can include a keyword and/or default value. Thus, the three cases above are
more completely specified as follows:
- symbol
Adds one to both the minimum and maximum number of non-keyword arguments accepted by the function.
The symbol is associated with an actual argument by position.
- (symbol default-form [supplied-symbol])
Adds one to the maximum number of non-keyword arguments accepted by the procedure.
The symbol is associated with an actual argument by position, and if no such argument is provided,
the default-form is evaluated to produce a value associated with symbol. If supplied-symbol is
specified, it is associated with t or nil indicating if the argument is provided.
No arg with a default-expr can appear before a symbol without a default-form and without a keyword.
- keyword symbol
The function requires a keyword-based argument using keyword. The symbol is associated
with a keyword-based actual argument using keyword.
- keyword (symbol default-form [supplied-symbol])
The function accepts a keyword-based argument using keyword. The symbol is associated
with a keyword-based actual argument using keyword, if supplied in an application; otherwise,
the default-expr is evaluated to obtain a value to associate with id. If supplied-symbol is
specified, it is associated with t or nil indicating if the argument is provided.
adp.
Returns the form of an element.
This form is the lisp form equivalent to a scribble one that the programmer wrote
within a scribble file. This form returned a value that can be retrieved with ADP:ELEMENT-VALUE.
Returns the value of an element.
This value is what a certain form returned within a scribble file. The form can be retrieved with ADP:ELEMENT-FORM.
Returns the ASDF component of a scribble file.
Returns all the elements of a scribble file.
Retrieves the lambda list of an adp function or macro whose name is SYMBOL.
A second value is returned specifing if SYMBOL does or does not denote an adp function or macro.
adp.
Exports the elements gathered by ADP.
This function must be implemented by the exporter and is called after all files are loaded.
SYSTEM argument must be specialized with a class defined with DEFINE-ADP-SYSTEM.
FILES is a list of ADP::SCRIBBLE-FILE objects. These objects has two attributes that can be retrieved
using ADP:FILE-COMPONENT and ADP:FILE-ELEMENTS. The former returns the ASDF component that represents
the file. The exporter must use the ASDF interface to retrieve information about this file like
its pathname. The latter is a list of ADP::SCRIBBLE-ELEMENT objects. Each object has two attributes
as well that can be retrieved with ADP:ELEMENT-VALUE and ADP:ELEMENT-FORM. The former returns
the value of the element. This value is what the exporter must print. The former is the form
that has generated the value. This can be useful for error messages.
Regarding the type of each file, they are specifically of type a class defined with ADP:DEFINE-ADP-FILE.
In fact, every file type defined with ADP:DEFINE-ADP-FILE has as direct superclass the
type ADP::SCRIBBLE-FILE.
All files are in the same order as they were loaded. The same goes to elements within a file.
racket-arg) &optional env) ¶racket-args) &optional env) ¶load-op) (c scribble-source-file)) ¶We can’t know where the output files will be stored. So, files must always be generated.
asdf/action.
load-op) (c adp-system)) ¶We can’t know where the output files will be stored. So, files must always be generated.
asdf/action.
prepare-op) (c adp-system)) ¶We can’t know where the output files will be stored. So, files must always be generated.
asdf/action.
load-op) (c scribble-source-file)) ¶asdf/action.
compile-op) (c scribble-source-file)) ¶asdf/action.
prepare-op) (c scribble-source-file)) ¶asdf/action.
load-op) (s adp-system)) ¶asdf/action.
prepare-op) (s adp-system)) ¶asdf/action.
A container with all the content files. The keys are the pathnames of the file relative to the asdf root file.
adp.
eval-error)) ¶eval-error)) ¶adp.
eval-error)) ¶eval-error)) ¶adp.
eval-error)) ¶eval-error)) ¶adp.
error.
(quote nil)
:error-condition
(quote nil)
:expression
adp.
(make-array 10 :fill-pointer 0)
:required-args
(make-array 10 :fill-pointer 0)
:optional-args
(make-hash-table :test (quote eq))
:key-args
:rest-arg
Represents an element in a scribble file.
Represents a unit of documentation that groups several elements.
Component class for a Scribble source file
| Jump to: | (
A D E F G I M O P R W |
|---|
| Jump to: | (
A D E F G I M O P R W |
|---|
| Jump to: | *
C D E F K N O R S T V |
|---|
| Jump to: | *
C D E F K N O R S T V |
|---|
| Jump to: | A C E F M P R S |
|---|
| Jump to: | A C E F M P R S |
|---|