This is the misc-extensions Reference Manual, version 4.0.6, generated automatically by Declt version 4.0 beta 2 "William Riker" on Tue Jul 15 06:00:18 2025 GMT+0.
misc-extensions/misc-extensions.asdmisc-extensions/src/defs.lispmisc-extensions/src/new-let.lispmisc-extensions/src/gmap.lispmisc-extensions/src/fn.lispmisc-extensions/src/tests.lispmisc-extensions/src/rev-fun-bind.lispmisc-extensions/src/define-class.lispmisc-extensions/src/contexts.lispmisc-extensions/src/context-tests.lispThe main system appears first, followed by any subsystem dependency.
misc-extensionsThe GMap iteration macro, plus a few other useful macros.
Scott L. Burson <Scott@sympoiesis.com>
Public domain
4.0.6
src (module).
Modules are listed depth-first from the system components tree.
misc-extensions/srcmisc-extensions (system).
defs.lisp (file).
new-let.lisp (file).
gmap.lisp (file).
fn.lisp (file).
tests.lisp (file).
rev-fun-bind.lisp (file).
define-class.lisp (file).
contexts.lisp (file).
context-tests.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
misc-extensions/misc-extensions.asdmisc-extensions/src/defs.lispmisc-extensions/src/new-let.lispmisc-extensions/src/gmap.lispmisc-extensions/src/fn.lispmisc-extensions/src/tests.lispmisc-extensions/src/rev-fun-bind.lispmisc-extensions/src/define-class.lispmisc-extensions/src/contexts.lispmisc-extensions/src/context-tests.lispmisc-extensions/misc-extensions.asdmisc-extensions (system).
misc-extensions/src/new-let.lispdefs.lisp (file).
src (module).
analyze-decls (function).
bcond-build-clause (function).
bcond-clause (function).
bound-decls (function).
expand-new-let (function).
new-let-bound-vars (function).
prune-decls (function).
split-level (function).
type-specifier-name? (function).
misc-extensions/src/gmap.lispnew-let.lisp (file).
src (module).
copy-gmap-type (function).
def-arg-type (macro).
def-gmap-arg-type (macro).
def-gmap-res-type (macro).
def-result-type (macro).
gmap (macro).
*gmap-arg-type-list* (special variable).
*gmap-result-type-list* (special variable).
gmap>arg-spec-lookup (function).
gmap>expand (function).
gmap>funcall (function).
gmap>let-specs (function).
gmap>param (function).
gmap>param>arg (function).
gmap>param>exit-test (function).
gmap>param>multi-let-specs (function).
gmap>param>multi-vars (function).
gmap>res-spec-lookup (function).
gmap>res-spec-lookup-1 (function).
gmap>res>cleanup (function).
gmap>res>init-clauses (function).
gmap>res>next (function).
keyword-name-deprecated (condition).
kind (reader method).
name (reader method).
misc-extensions/src/fn.lispmisc-extensions/src/tests.lispfn.lisp (file).
src (module).
test-new-syntax (function).
test-old-syntax (function).
misc-extensions/src/rev-fun-bind.lisptests.lisp (file).
src (module).
misc-extensions/src/define-class.lisprev-fun-bind.lisp (file).
src (module).
add-define-class-extension (function).
define-class (macro).
*tab-width* (special variable).
remove-indentation (function).
misc-extensions/src/contexts.lispdefine-class.lisp (file).
src (module).
defcontext (macro).
deflex (macro).
deflex-reinit (macro).
isetq (macro).
make-load-form (method).
with-context (macro).
with-contexts (macro).
context (structure).
context-all-fns (reader).
(setf context-all-fns) (writer).
context-all-vars (reader).
(setf context-all-vars) (writer).
context-bind-fns (reader).
(setf context-bind-fns) (writer).
context-bind-vars (reader).
(setf context-bind-vars) (writer).
context-constructor (reader).
(setf context-constructor) (writer).
context-instance-default-element (constant).
context-macros (reader).
(setf context-macros) (writer).
context-name (reader).
(setf context-name) (writer).
context-p (function).
context-parameter-list (reader).
(setf context-parameter-list) (writer).
copy-context (function).
make-context (function).
misc-extensions/src/context-tests.lispcontexts.lisp (file).
src (module).
test-context-0 (function).
test-context-1 (function).
test-context-2 (function).
test-contexts (function).
Packages are listed by definition order.
misc-extensions.define-classmisc-extensions.lexical-contextsmisc-extensions.new-letmisc-extensions.gmapmisc-extensions.rev-fun-bindmisc-extensions.define-classcommon-lisp.
add-define-class-extension (function).
define-class (macro).
*tab-width* (special variable).
remove-indentation (function).
misc-extensions.lexical-contextslexical-contexts
common-lisp.
defcontext (macro).
deflex (macro).
deflex-reinit (macro).
isetq (macro).
with-context (macro).
with-contexts (macro).
context (structure).
context-all-fns (reader).
(setf context-all-fns) (writer).
context-all-vars (reader).
(setf context-all-vars) (writer).
context-bind-fns (reader).
(setf context-bind-fns) (writer).
context-bind-vars (reader).
(setf context-bind-vars) (writer).
context-constructor (reader).
(setf context-constructor) (writer).
context-instance-default-element (constant).
context-macros (reader).
(setf context-macros) (writer).
context-name (reader).
(setf context-name) (writer).
context-p (function).
context-parameter-list (reader).
(setf context-parameter-list) (writer).
copy-context (function).
make-context (function).
test-context-0 (function).
test-context-1 (function).
test-context-2 (function).
test-contexts (function).
misc-extensions.new-letnew-let
common-lisp.
analyze-decls (function).
bcond-build-clause (function).
bcond-clause (function).
bound-decls (function).
expand-new-let (function).
new-let-bound-vars (function).
prune-decls (function).
split-level (function).
type-specifier-name? (function).
misc-extensions.gmapgmap
common-lisp.
copy-gmap-type (function).
def-arg-type (macro).
def-gmap-arg-type (macro).
def-gmap-res-type (macro).
def-result-type (macro).
gmap (macro).
*gmap-arg-type-list* (special variable).
*gmap-result-type-list* (special variable).
gmap>arg-spec-lookup (function).
gmap>expand (function).
gmap>funcall (function).
gmap>let-specs (function).
gmap>param (function).
gmap>param>arg (function).
gmap>param>exit-test (function).
gmap>param>multi-let-specs (function).
gmap>param>multi-vars (function).
gmap>res-spec-lookup (function).
gmap>res-spec-lookup-1 (function).
gmap>res>cleanup (function).
gmap>res>init-clauses (function).
gmap>res>next (function).
keyword-name-deprecated (condition).
kind (generic reader).
name (generic reader).
test-new-syntax (function).
test-old-syntax (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
A generalization of CL:COND that makes it convenient to compute a value in
the predicate expression of a clause and then use that value in the consequent.
If the predicate expression is a LET form, then the scope of the variables bound
by the LET is extended to include the consequent expressions. For example:
(cond ((let ((x (foo)))
(bar x))
(baz x)))
Here the X in (BAZ X) is the one bound to the result of (FOO).
A generalization of CL:COND that makes it convenient to compute a value in
the predicate expression of a clause and then use that value in the consequent.
If the predicate expression is a LET form, then the scope of the variables bound
by the LET is extended to include the consequent expressions. For example:
(cond ((let ((x (foo)))
(bar x))
(baz x)))
Here the X in (BAZ X) is the one bound to the result of (FOO).
Defines a GMap arg-type. Syntax is identical to ‘defun’. The body should
return a list of 1 to 6 elements: (0, "init") the initial value of the
state variable; (1, "exitp"), if non-nil, a function of one argument which
is called on the state variable, a true result causing the iteration to
exit; (2, "argfn"), if non-nil, a function of one argument which is called
on the state variable to get the value to be used on this iteration; (3,
"nextfn"), if non-nil, a function of one argument which is called on the
state variable to get the new value of same; (4, "let-specs") a list of
clauses for an ‘nlet’ that will be wrapped around the entire expansion; and
(5, "wrapper-fn"), if non-nil, a function to be called on the entire
expansion, whose result will be used as the new entire expansion.
It is also possible for an arg-type to generate multiple arguments. If element 2, "argfn", is of the form ‘(:values N FN)’, FN should be a function returning N values, which will be passed as separate arguments to the function being mapped.
Defines a GMap arg-type. Syntax is identical to ‘defun’. The body should
return a list of 1 to 5 elements: (0, "init") the initial value of the
state variable; (1, "exitp"), if non-nil, a function of one argument which
is called on the state variable, a true result causing the iteration to
exit; (2, "argfn"), if non-nil, a function of one argument which is called
on the state variable to get the value to be used on this iteration; (3,
"nextfn"), if non-nil, a function of one argument which is called on the
state variable to get the new value of same; (4, "let-specs") a list of
clauses for an ‘nlet’ that will be wrapped around the entire expansion; and
(5, "wrapper-fn"), if non-nil, a function to be called on the entire
expansion, whose result will be used as the new entire expansion.
It is also possible for an arg-type to generate multiple arguments. If
element 2, "argfn", is of the form ‘(:values N FN)’, FN should be a function
returning N values, which will be passed as separate arguments to the function
being mapped.
This is the backward-compatibility version of this macro; when ‘name’ is not in the keyword package, it also tries to identically define the keyword symbol of the same name, though it checks for collisions first. If a collision does occur, you can resolve it by changing at least one of the ‘def-gmap-arg-type’ forms to ‘def-arg-type’, which does not attempt to define the keyword version of the name. Of course, you will also need to update any references in the old syntax ‘(:name ...)’ to the new syntax ‘(:arg name ...)’.
Defines a GMap result-type. Syntax is identical to ‘defun’. The body should
return a list of 2 to 5 elements: (0, "init") the initial value of the state
variable; (1, "resfn") a function of two arguments which is called on the
state variable and the current value of the function being mapped, returning
the new value of the state variable; (2, "cleanup"), if non-nil, a function
of one argument which is called on the final value of the state variable to
get the value of the ‘gmap’ form; (3, "filterp"), if non-nil, a predicate
of one argument which is called on the current value of the function being
mapped, a false value causing "resfn" not to be called on this iteration (and
the state variable to be unchanged); and (4, "let-specs") a list of
clauses for an ‘nlet’ that will be wrapped around the entire expansion.
It is also possible for a result-type to consume more than one value of the
function being mapped. If element 1, "resfn", is of the form ‘(:consume N
FN)’, FN should be a function of N + 1 arguments, and will receive N values
from the function being mapped.
This is the backward-compatibility version of this macro; when ‘name’ is not in the keyword package, it also tries to identically define the keyword symbol of the same name, though it checks for collisions first. If a collision does occur, you can resolve it by changing at least one of the ‘def-gmap-res-type’ forms to ‘def-res-type’, which does not attempt to define the keyword version of the name. Of course, you will also need to update any references in the old syntax ‘(:name ...)’ to the new syntax ‘(:result name ...)’.
Defines a GMap result-type. Syntax is identical to ‘defun’. The body should
return a list of 2 to 5 elements: (0, "init") the initial value of the state
variable; (1, "resfn") a function of two arguments which is called on the
state variable and the current value of the function being mapped, returning
the new value of the state variable; (2, "cleanup"), if non-nil, a function
of one argument which is called on the final value of the state variable to
get the value of the ‘gmap’ form; (3, "filterp"), if non-nil, a predicate
of one argument which is called on the current value of the function being
mapped, a false value causing "resfn" not to be called on this iteration (and
the state variable to be unchanged); and (4, "let-specs") a list of
clauses for an ‘nlet’ that will be wrapped around the entire expansion.
It is also possible for a result-type to consume more than one value of the function being mapped. If element 1, "resfn", is of the form ‘(:consume N FN)’, FN should be a function of N + 1 arguments, and will receive N values from the function being mapped.
A macro to make class definitions less verbose. Upwardly compatible with
‘cl:defclass’, but adds additional syntax:
- The first element of a slot specifier, which is normally a slot name,
can instead be a list (slot-name initform); an ‘:initform’ option will
be generated
- ‘:may-init’ generates ‘:initarg :slot-name’
- ‘:must-init’ generates ‘:initarg :slot-name’, and also an ‘:initform’
that signals an error if the argument is not provided to ‘make-instance’
- ‘:readable’ and ‘:accessible’ generate ‘:reader’ resp. ‘:accessor’ slot
options; the name given will be the slot name, unless a _class_ option
‘:conc-name’ is supplied, in which case the conc-name will be prepended
- Additionally, ‘:constant’ is an abbreviation for ‘:must-init :readable’
if the spec contains no initform, or ‘:may-init :readable’ if there is
an initform (in either syntax)
- And ‘:variable’ is an abbreviation for ‘:may-init :accessible’
- A doc string can appear anywhere in the slot options; a ‘:documentation’
slot option will be generated
- Or, you can use ‘:doc’ as an abbreviation for ‘:documentation’
Also, a doc string for the class can be placed just before the slot-specs.
Example:
(define-class convertible (car)
"A convertible is a car with a top that can be either down or up."
((top-color :must-init :readable
"The color of the top.")
((top-state ’:up) :accessible
"The current state of the top, ‘:down’ or ‘:up’.")))
Declares ‘var’ as a global lexical variable, and if ‘val’ is supplied and ‘var’ is not already bound, initializes it to ‘val’. ‘doc’, if supplied, is taken as a documentation string. In some implementations (e.g. Scieneer), locally rebinding the same name is not permitted; in most, it is permitted but creates a new lexical variable, with no effect on the global one.
Declares ‘var’ as a global lexical variable, and initializes it to ‘val’. ‘doc’, if supplied, is taken as a documentation string. In some implementations (e.g. Scieneer), locally rebinding the same name is not permitted; in most, it is permitted but creates a new lexical variable, with no effect on the global one.
A variant of ‘lambda’ with two features: (a) the name is shorter, and (b)
it automatically generates an ‘ignore’ declaration for any parameter
whose name begins with an underscore. If the parameter’s name is just ‘_’,
renames it to a gensym, so as to avoid duplicate-parameter errors (this
applies to any symbol named ‘_’, regardless of package).
Note that
#’(fn ...)
doesn’t work, since CL doesn’t have Zetalisp-style lambda macros; you have
to say just
(fn ...)
This is the modern style anyway, I think.
A generalized mapping macro. Applies ‘fn’ to the successive values generated
by the ‘arg-specs’, analagously to ‘mapcar’; that is, on each iteration, each
arg-spec yields one value, and ‘fn’ is called with these values as arguments.
(‘fn’ can be given as ‘:id’, which is equivalent to ‘#’values’.)
The values returned by ‘fn’ are accumulated into a result according to
‘res-spec’. The ‘res-spec’ is either a list whose car is a predefined result
type, or a list whose car is ‘nil’ and whose cdr has the same form as the value
of a result type expander (see ‘def-gmap-res-type’); or, the ‘res-spec’ can be
a symbol, which is shorthand for a list of that symbol; or, it can be a list
whose car is ‘:values’ and whose cdr is a list of result-specs. Similarly,
each of the ‘arg-specs’ is either a list whose car is a predefined arg type,
or a list whose car is ‘nil’ and whose cdr has the same form as the value of
an arg type expander (see ‘def-gmap-arg-type’).
"Interactive ‘setq’": can be used on previously-undeclared variables without getting ugly warnings or causing the variable to be declared special. Not to be used in code!!!
A generalization of CL:LET that better supports nested bindings and multiple
values. Syntax: (let (<clause>*) <body>). The <clause> syntax is more general
than for CL:LET:
<clause> ::= <symbol> ; binds to NIL
| ( <symbol> ) ; likewise
| <clause1>
<clause1> ::= ( <symbol>+ <form> ) ; binding
| ( <clause1>+ ) ; nesting
When a clause begins with more than one variable name, they are to be bound to
successive values of the form. The nesting of clauses indicates sequencing of
bindings; more deeply nested clauses may reference bindings of shallower clauses.
All bindings at a given depth are done in parallel. This allows arbitrary
combinations of parallel and sequential binding. Standard declarations at the
head of BODY are handled correctly, though nonstandard ones may not be. If two
variables of the same name are bound at different levels, any declaration
applies to the inner one.
A generalization of CL:LET that better supports nested bindings and multiple
values. Syntax: (let (<clause>*) <body>). The <clause> syntax is more general
than for CL:LET:
<clause> ::= <symbol> ; binds to NIL
| ( <symbol> ) ; likewise
| <clause1>
<clause1> ::= ( <symbol>+ <form> ) ; binding
| ( <clause1>+ ) ; nesting
When a clause begins with more than one variable name, they are to be bound to
successive values of the form. The nesting of clauses indicates sequencing of
bindings; more deeply nested clauses may reference bindings of shallower clauses.
All bindings at a given depth are done in parallel. This allows arbitrary
combinations of parallel and sequential binding. Standard declarations at the
head of BODY are handled correctly, though nonstandard ones may not be. If two
variables of the same name are bound at different levels, any declaration
applies to the inner one.
Just like ‘flet’ except that the first subform is the form that computes the value, and the remaining subforms are the binding clauses.
Just like ‘labels’ except that the first subform is the form that computes the value, and the remaining subforms are the binding clauses.
Just like ‘macrolet’ except that the first subform is the form that computes the value, and the remaining subforms are the binding clauses.
Adds a keyword slot option to ‘define-class’. ‘option’ should be a keyword, and ‘ext-fn’ the name of a function. If the option is used for any slots in a ‘define-class’ form, the function will be called (at load time) with two arguments, the class name and the list of slots on which the option appeared.
If you shadow the name of a CL builtin that is also a GMap arg and/or result type, you will want to use this to copy the definition(s) from the CL symbol to your shadowing symbol.
An attempt to give the user a clue if they run into this.
A list of all GMAP arg types that have been defined.
A list of all GMAP result types that have been defined.
Returns two values. The first value is a cons of: (a) for the bound declarations at the head of ‘body’, an alist from variable name to a list of declarations affecting that variable; (b) a list of the remaining (free) declarations. The second value is ‘body’ with the declarations stripped off.
name.
De-indents the second and subsequent lines of ‘str’ by an amount equal to the minimum indentation of those lines.
keyword-name-deprecated)) ¶keyword-name-deprecated)) ¶structure-object.
| Jump to: | (
A B C D E F G I K L M N P R S T W |
|---|
| Jump to: | (
A B C D E F G I K L M N P R S T W |
|---|
| Jump to: | *
A B C K M N P S |
|---|
| Jump to: | *
A B C K M N P S |
|---|
| Jump to: | C D F G K M N P R S T |
|---|
| Jump to: | C D F G K M N P R S T |
|---|