This is the org.tfeb.hax Reference Manual, version 8.2.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 18:04:43 2024 GMT+0.
org.tfeb.hax/org.tfeb.hax.asdorg.tfeb.hax/collecting.lisporg.tfeb.hax/wrapping-standard.lisporg.tfeb.hax/iterate.lisporg.tfeb.hax/dynamic-state.lisporg.tfeb.hax/memoize.lisporg.tfeb.hax/abstract-classes.lisporg.tfeb.hax/singleton-classes.lisporg.tfeb.hax/cs-forms.lisporg.tfeb.hax/read-package.lisporg.tfeb.hax/comment-form.lisporg.tfeb.hax/define-functions.lisporg.tfeb.hax/trace-macroexpand.lisporg.tfeb.hax/binding.lisporg.tfeb.hax/stringtable.lisporg.tfeb.hax/object-accessors.lisporg.tfeb.hax/utilities.lisporg.tfeb.hax/simple-loops.lisporg.tfeb.hax/spam.lisporg.tfeb.hax/metatronic.lisporg.tfeb.hax/slog.lisporg.tfeb.hax/hax-cometh.lisporg.tfeb.hax.slogorg.tfeb.hax.read-packageorg.tfeb.hax.define-functionsorg.tfeb.hax.iterateorg.tfeb.hax.trace-macroexpandorg.tfeb.hax.simple-loopsorg.tfeb.hax.stringtableorg.tfeb.hax.comment-formorg.tfeb.hax.metatronicorg.tfeb.hax.bindingorg.tfeb.hax.abstract-classesorg.tfeb.hax.spamorg.tfeb.hax.wrapping-standardorg.tfeb.hax.object-accessorsorg.tfeb.hax.collectingorg.tfeb.hax.utilitiesorg.tfeb.hax.singleton-classesorg.tfeb.hax.cs-formsorg.tfeb.hax.dynamic-stateorg.tfeb.hax.memoizeThe main system appears first, followed by any subsystem dependency.
org.tfeb.haxTFEB hax
Tim Bradshaw
MIT
8.2.0
closer-mop (system).
collecting.lisp (file).
wrapping-standard.lisp (file).
iterate.lisp (file).
dynamic-state.lisp (file).
memoize.lisp (file).
abstract-classes.lisp (file).
singleton-classes.lisp (file).
cs-forms.lisp (file).
read-package.lisp (file).
comment-form.lisp (file).
define-functions.lisp (file).
trace-macroexpand.lisp (file).
binding.lisp (file).
stringtable.lisp (file).
object-accessors.lisp (file).
utilities.lisp (file).
simple-loops.lisp (file).
spam.lisp (file).
metatronic.lisp (file).
slog.lisp (file).
hax-cometh.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
org.tfeb.hax/org.tfeb.hax.asdorg.tfeb.hax/collecting.lisporg.tfeb.hax/wrapping-standard.lisporg.tfeb.hax/iterate.lisporg.tfeb.hax/dynamic-state.lisporg.tfeb.hax/memoize.lisporg.tfeb.hax/abstract-classes.lisporg.tfeb.hax/singleton-classes.lisporg.tfeb.hax/cs-forms.lisporg.tfeb.hax/read-package.lisporg.tfeb.hax/comment-form.lisporg.tfeb.hax/define-functions.lisporg.tfeb.hax/trace-macroexpand.lisporg.tfeb.hax/binding.lisporg.tfeb.hax/stringtable.lisporg.tfeb.hax/object-accessors.lisporg.tfeb.hax/utilities.lisporg.tfeb.hax/simple-loops.lisporg.tfeb.hax/spam.lisporg.tfeb.hax/metatronic.lisporg.tfeb.hax/slog.lisporg.tfeb.hax/hax-cometh.lisporg.tfeb.hax/collecting.lisporg.tfeb.hax (system).
collect-into (function).
collecting (macro).
collecting-values (macro).
collector-contents (function).
make-collector (function).
nconc-collector-onto (function).
nconc-collectors (function).
with-accumulators (macro).
with-collectors (macro).
org.tfeb.hax/wrapping-standard.lisporg.tfeb.hax (system).
wrapping-standard (method combination).
org.tfeb.hax/iterate.lisporg.tfeb.hax (system).
iterate (macro).
iterate* (macro).
iterating (macro).
iterating* (macro).
expand-iterate (function).
expand-iterating (function).
extract-ignore/other-decls (function).
org.tfeb.hax/dynamic-state.lisporg.tfeb.hax (system).
define-dynamic-state (macro).
org.tfeb.hax/memoize.lisporg.tfeb.hax (system).
clear-memoized-function (function).
clear-memoized-functions (function).
def-memoized-function (macro).
function-memoized-p (function).
memoize-function (function).
memoized-labels (macro).
unmemoize-function (function).
unmemoize-functions (function).
*memoized-functions* (special variable).
make-memo (function).
org.tfeb.hax/abstract-classes.lisporg.tfeb.hax (system).
abstract-class (class).
define-abstract-class (macro).
define-final-class (macro).
final-class (class).
make-instance (method).
validate-superclass (method).
validate-superclass (method).
validate-superclass (method).
validate-superclass (method).
org.tfeb.hax/singleton-classes.lisporg.tfeb.hax (system).
initialize-instance (method).
make-instance (method).
reset-singleton-classes (function).
singleton-class (class).
validate-superclass (method).
validate-superclass (method).
validate-superclass (method).
*singleton-classes* (special variable).
org.tfeb.hax/cs-forms.lisporg.tfeb.hax (system).
make-cs-form-readtable (function).
org.tfeb.hax/read-package.lisporg.tfeb.hax (system).
make-read-package-readtable (function).
*read-package-package* (special variable).
org.tfeb.hax/comment-form.lisporg.tfeb.hax (system).
make-comment-form-readtable (function).
org.tfeb.hax/define-functions.lisporg.tfeb.hax (system).
define-function (macro).
define-functions (macro).
define-macro-function (macro).
define-macro-functions (macro).
org.tfeb.hax/trace-macroexpand.lisporg.tfeb.hax (system).
*trace-macroexpand-maybe-trace* (special variable).
*trace-macroexpand-print-circle* (special variable).
*trace-macroexpand-print-length* (special variable).
*trace-macroexpand-print-level* (special variable).
*trace-macroexpand-printer* (special variable).
*trace-macroexpand-trace-hook* (special variable).
*trace-macroexpand-traced-names* (special variable).
*trace-macroexpand-traced-packages* (special variable).
call/macroexpand-tracing (function).
macroexpand-traced-p (function).
trace-macro (macro).
trace-macro-package (function).
trace-macroexpand (function).
untrace-macro (macro).
untrace-macro-package (function).
with-macroexpand-tracing (macro).
*should-be-tracing-p* (special variable).
*wrapped-macroexpand-hook* (special variable).
canonicalise-package-designator (function).
insane-state (condition).
state-sanity-check (function).
trace-macroexpand-hook (function).
trace-macroexpand-trace-p (function).
trace-macros (function).
untrace-macros (function).
org.tfeb.hax/binding.lispcollecting.lisp (file).
iterate.lisp (file).
org.tfeb.hax (system).
bind (macro).
bind/destructuring (macro).
bind/macro (macro).
bind/values (macro).
binding (macro).
parse-binding-form (function).
walk-binding-body (function).
org.tfeb.hax/stringtable.lispcollecting.lisp (file).
iterate.lisp (file).
org.tfeb.hax (system).
*stringtable* (special variable).
*stringtable-fallback-absorb-special* (special variable).
copy-stringtable (function).
get-stringtable-special-character (function).
make-stringtable-readtable (function).
make-stringtable-special-character (function).
print-object (method).
read-string-with-stringtable (function).
set-stringtable-newline-skipper (function).
set-stringtable-special-character (function).
stringtable-escape-character (reader).
(setf stringtable-escape-character) (writer).
fallback (function).
make-stringtable (function).
read-string-with-stringtable/list (function).
read-string-with-stringtable/suppressed (function).
stringtable (structure).
stringtable-error (condition).
stringtable-error-message (reader method).
stringtable-p (function).
stringtable-reader-error (condition).
stringtable-specials (reader).
(setf stringtable-specials) (writer).
org.tfeb.hax/object-accessors.lisporg.tfeb.hax (system).
with-object-accessors (macro).
org.tfeb.hax/utilities.lispcollecting.lisp (file).
iterate.lisp (file).
org.tfeb.hax (system).
parse-docstring-body (function).
parse-simple-body (function).
org.tfeb.hax/simple-loops.lispcollecting.lisp (file).
iterate.lisp (file).
utilities.lisp (file).
org.tfeb.hax (system).
do-failing (macro).
do-failing* (macro).
do-passing (macro).
do-passing* (macro).
doing (macro).
doing* (macro).
dolists (macro).
escaping (macro).
failing (macro).
failing* (macro).
looping (macro).
looping* (macro).
looping/values (macro).
looping/values* (macro).
passing (macro).
passing* (macro).
expand-doing (function).
expand-looping (function).
expand-simple-loop (function).
parse-clauses (function).
org.tfeb.hax/spam.lispsimple-loops.lisp (file).
org.tfeb.hax (system).
all-of (function).
any (function).
cons-matches (function).
head-matches (function).
is (function).
is-type (function).
lambda-list-keyword (function).
list*-matches (function).
list-matches (function).
list-of (function).
matching (macro).
matchp (function).
none-of (function).
repeating-list-of (function).
some-of (function).
var (function).
org.tfeb.hax/metatronic.lisputilities.lisp (file).
org.tfeb.hax (system).
define-compiler-macro/m (macro).
defmacro/m (macro).
macrolet/m (macro).
metatronize (function).
rewrite-sources (function).
rewrite-targets (function).
*default-metatronize-symbol-rewriter* (special variable).
check-arglist (function).
m2 (function).
metatronic-arglist-warning (condition).
org.tfeb.hax/slog.lispsimple-loops.lisp (file).
collecting.lisp (file).
spam.lisp (file).
metatronic.lisp (file).
org.tfeb.hax (system).
*default-log-entry-type* (special variable).
*fallback-log-destination-handler* (special variable).
*log-entry-formatter* (special variable).
close-open-log-files (function).
closing-opened-log-files (macro).
current-log-files (function).
default-log-entry-formatter (function).
flush-open-log-files (function).
get-precision-universal-time (function).
log-entry (condition).
log-entry-internal-time (reader method).
log-file-truename (function).
log-files-sane-p (function).
logging (macro).
once-only-log-entry (condition).
print-object (method).
reset-precision-time-offsets (function).
simple-log-entry (condition).
slog (function).
slog-to (generic function).
*it0* (special variable).
*log-files* (special variable).
*slfs* (special variable).
*ut0* (special variable).
call/closing-opened-log-files (function).
canonicalize-destination (function).
close-log-file (function).
close-open-log-files-up-to (function).
compute-image-time-offsets (function).
default-precision-time-rate (constant).
ensure-log-entry (function).
ensure-log-entry-typespec (function).
ensure-log-file (generic function).
log-entry-logged (reader method).
log-entry-logged-p (generic function).
(setf log-entry-logged-p) (generic function).
log-file (structure).
log-file-open-p (function).
log-file-p (function).
log-file-pathname (reader).
log-file-stream (reader).
(setf log-file-stream) (writer).
make-log-file (function).
open-log-file-pathname (function).
org.tfeb.hax/hax-cometh.lispcollecting.lisp (file).
wrapping-standard.lisp (file).
iterate.lisp (file).
dynamic-state.lisp (file).
memoize.lisp (file).
abstract-classes.lisp (file).
singleton-classes.lisp (file).
cs-forms.lisp (file).
read-package.lisp (file).
comment-form.lisp (file).
define-functions.lisp (file).
trace-macroexpand.lisp (file).
binding.lisp (file).
stringtable.lisp (file).
object-accessors.lisp (file).
utilities.lisp (file).
simple-loops.lisp (file).
spam.lisp (file).
metatronic.lisp (file).
slog.lisp (file).
org.tfeb.hax (system).
Packages are listed by definition order.
org.tfeb.hax.slogorg.tfeb.hax.read-packageorg.tfeb.hax.define-functionsorg.tfeb.hax.iterateorg.tfeb.hax.trace-macroexpandorg.tfeb.hax.simple-loopsorg.tfeb.hax.stringtableorg.tfeb.hax.comment-formorg.tfeb.hax.metatronicorg.tfeb.hax.bindingorg.tfeb.hax.abstract-classesorg.tfeb.hax.spamorg.tfeb.hax.wrapping-standardorg.tfeb.hax.object-accessorsorg.tfeb.hax.collectingorg.tfeb.hax.utilitiesorg.tfeb.hax.singleton-classesorg.tfeb.hax.cs-formsorg.tfeb.hax.dynamic-stateorg.tfeb.hax.memoizeorg.tfeb.hax.slog*default-log-entry-type* (special variable).
*fallback-log-destination-handler* (special variable).
*log-entry-formatter* (special variable).
close-open-log-files (function).
closing-opened-log-files (macro).
current-log-files (function).
default-log-entry-formatter (function).
flush-open-log-files (function).
get-precision-universal-time (function).
log-entry (condition).
log-entry-internal-time (generic reader).
log-file-truename (function).
log-files-sane-p (function).
logging (macro).
once-only-log-entry (condition).
reset-precision-time-offsets (function).
simple-log-entry (condition).
slog (function).
slog-to (generic function).
*it0* (special variable).
*log-files* (special variable).
*slfs* (special variable).
*ut0* (special variable).
call/closing-opened-log-files (function).
canonicalize-destination (function).
close-log-file (function).
close-open-log-files-up-to (function).
compute-image-time-offsets (function).
default-precision-time-rate (constant).
ensure-log-entry (function).
ensure-log-entry-typespec (function).
ensure-log-file (generic function).
log-entry-logged (generic reader).
log-entry-logged-p (generic function).
(setf log-entry-logged-p) (generic function).
log-file (structure).
log-file-open-p (function).
log-file-p (function).
log-file-pathname (reader).
log-file-stream (reader).
(setf log-file-stream) (writer).
make-log-file (function).
open-log-file-pathname (function).
org.tfeb.hax.read-packagecommon-lisp.
make-read-package-readtable (function).
*read-package-package* (special variable).
org.tfeb.hax.define-functionscommon-lisp.
define-function (macro).
define-functions (macro).
define-macro-function (macro).
define-macro-functions (macro).
org.tfeb.hax.iteratecommon-lisp.
iterate (macro).
iterate* (macro).
iterating (macro).
iterating* (macro).
expand-iterate (function).
expand-iterating (function).
extract-ignore/other-decls (function).
org.tfeb.hax.trace-macroexpandcommon-lisp.
*trace-macroexpand-maybe-trace* (special variable).
*trace-macroexpand-print-circle* (special variable).
*trace-macroexpand-print-length* (special variable).
*trace-macroexpand-print-level* (special variable).
*trace-macroexpand-printer* (special variable).
*trace-macroexpand-trace-hook* (special variable).
*trace-macroexpand-traced-names* (special variable).
*trace-macroexpand-traced-packages* (special variable).
call/macroexpand-tracing (function).
macroexpand-traced-p (function).
trace-macro (macro).
trace-macro-package (function).
trace-macroexpand (function).
untrace-macro (macro).
untrace-macro-package (function).
with-macroexpand-tracing (macro).
*should-be-tracing-p* (special variable).
*wrapped-macroexpand-hook* (special variable).
canonicalise-package-designator (function).
insane-state (condition).
state-sanity-check (function).
trace-macroexpand-hook (function).
trace-macroexpand-trace-p (function).
trace-macros (function).
untrace-macros (function).
org.tfeb.hax.simple-loopscommon-lisp.
org.tfeb.hax.collecting.
org.tfeb.hax.iterate.
org.tfeb.hax.utilities.
do-failing (macro).
do-failing* (macro).
do-passing (macro).
do-passing* (macro).
doing (macro).
doing* (macro).
dolists (macro).
escaping (macro).
failing (macro).
failing* (macro).
looping (macro).
looping* (macro).
looping/values (macro).
looping/values* (macro).
passing (macro).
passing* (macro).
expand-doing (function).
expand-looping (function).
expand-simple-loop (function).
parse-clauses (function).
org.tfeb.hax.stringtablecommon-lisp.
org.tfeb.hax.collecting.
org.tfeb.hax.iterate.
*stringtable* (special variable).
*stringtable-fallback-absorb-special* (special variable).
copy-stringtable (function).
get-stringtable-special-character (function).
make-stringtable-readtable (function).
make-stringtable-special-character (function).
read-string-with-stringtable (function).
set-stringtable-newline-skipper (function).
set-stringtable-special-character (function).
stringtable-escape-character (reader).
(setf stringtable-escape-character) (writer).
fallback (function).
make-stringtable (function).
read-string-with-stringtable/list (function).
read-string-with-stringtable/suppressed (function).
stringtable (structure).
stringtable-error (condition).
stringtable-error-message (generic reader).
stringtable-p (function).
stringtable-reader-error (condition).
stringtable-specials (reader).
(setf stringtable-specials) (writer).
org.tfeb.hax.comment-formcommon-lisp.
make-comment-form-readtable (function).
org.tfeb.hax.metatroniccommon-lisp.
org.tfeb.hax.utilities.
define-compiler-macro/m (macro).
defmacro/m (macro).
macrolet/m (macro).
metatronize (function).
rewrite-sources (function).
rewrite-targets (function).
*default-metatronize-symbol-rewriter* (special variable).
check-arglist (function).
m2 (function).
metatronic-arglist-warning (condition).
org.tfeb.hax.bindingcommon-lisp.
org.tfeb.hax.collecting.
org.tfeb.hax.iterate.
bind (macro).
bind/destructuring (macro).
bind/macro (macro).
bind/values (macro).
binding (macro).
parse-binding-form (function).
walk-binding-body (function).
org.tfeb.hax.abstract-classesorg.tfeb.hax.final-classes
closer-common-lisp.
abstract-class (class).
define-abstract-class (macro).
define-final-class (macro).
final-class (class).
org.tfeb.hax.spamcommon-lisp.
org.tfeb.hax.simple-loops.
all-of (function).
any (function).
cons-matches (function).
head-matches (function).
is (function).
is-type (function).
lambda-list-keyword (function).
list*-matches (function).
list-matches (function).
list-of (function).
matching (macro).
matchp (function).
none-of (function).
repeating-list-of (function).
some-of (function).
var (function).
org.tfeb.hax.wrapping-standardcommon-lisp.
wrapping-standard (method combination).
org.tfeb.hax.object-accessorscommon-lisp.
with-object-accessors (macro).
org.tfeb.hax.collectingcommon-lisp.
collect-into (function).
collecting (macro).
collecting-values (macro).
collector-contents (function).
make-collector (function).
nconc-collector-onto (function).
nconc-collectors (function).
with-accumulators (macro).
with-collectors (macro).
org.tfeb.hax.utilitiescommon-lisp.
parse-docstring-body (function).
parse-simple-body (function).
org.tfeb.hax.singleton-classescloser-common-lisp.
reset-singleton-classes (function).
singleton-class (class).
*singleton-classes* (special variable).
org.tfeb.hax.cs-formscommon-lisp.
make-cs-form-readtable (function).
org.tfeb.hax.dynamic-statecommon-lisp.
define-dynamic-state (macro).
org.tfeb.hax.memoizecommon-lisp.
clear-memoized-function (function).
clear-memoized-functions (function).
def-memoized-function (macro).
function-memoized-p (function).
memoize-function (function).
memoized-labels (macro).
unmemoize-function (function).
unmemoize-functions (function).
*memoized-functions* (special variable).
make-memo (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
The default log entry type for SLOG
This is SIMPLE-LOG-ENTRY by default.
The default current stringtable
Should fallback functions absorb their special?
The default fallback listens to this variable. User fallbacks probably should as well.
Should we even consider tracing?
If this is false then don’t trace, at all. Overrides everything else.
The value of *PRINT-CIRCLE* used when tracing macroexpansions
The value of *PRINT-LENGTH* used when tracing macroexpansions
The value of *PRINT-LEVEL* used when tracing macroexpansions
Printer for traced macro expansions
If this is not NIL it should be a designator for a function of four
arguments: the stream to print on, the macro form, the expanded
form and the environment.
If this is not NIL then the function is called without any
locally-bound values for printer-control variables, so
*TRACE-MACROEXPAND-PRINT-LENGTH* *TRACE-MACROEXPAND-PRINT-LEVEL* &
*TRACE-MACROEXPAND-PRINT-CIRCLE* are not used.
The return value is ignored.
If not NIL a function which determines whether a macro is traced.
If this variable is not NIL it should be bound to a function
designator which determines if a given macro is traced. This function
completely replaces the built-in mechanism which uses
*TRACE-MACROEXPAND-TRACED-PACKAGES* and
*TRACE-MACROEXPAD-TRACED-NAMES*. The function is called with the
macro function, the form being expanded and the environment (the same
arguments as the function bound to *MACROEXPAND-HOOK*, which see).
The macro is traced if it returns true.
This mechanism can be overridden by *TRACE-MACROEXPAND-MAYBE-TRACE*
A list of macro names to trace.
If a macro’s name is on this list, then it’s traced.
Macros are traced as specified by this list and
*TRACE-MACROEXPAND-TRACED-PACKAGES*: macros are traced if they are on
this list or if their package matches
*TRACE-MACROEXPAND-TRACED-PACKAGES*. This means that to trace only
specific macros you want *TRACE-MACROEXPAND-TRACED-PACKAGES* to be
empty, while to trace all macros visible in a package you want to use
*TRACE-MACROEXPAND-TRACED-PACKAGES*.
This mechanism can be overridden by *TRACE-MACROEXPAND-TRACE-HOOK* & *TRACE-MACROEXPAND-MAYBE-TRACE*
A list of package designators in which macros should be traced.
Macros whose names are accessible in packages specified by this list
are traced. Each element is either: a package, a package name, NIL or
T. NIL means ’this package’, T means ’all packages’.
This list will canonicalised to contain either strings, T or NIL by
TRACE-MACRO-PACKAGE and UNTRACE-MACRO-PACKAGE.
Macros are traced as specified by this list and
*TRACE-MACROEXPAD-TRACED-NAMES*: tracing happens if the macros’
package matches this list, or its name is in
*TRACE-MACROEXPAD-TRACED-NAMES*. This means that to trace only
specific macros you want this list to be empty.
This mechanism can be overridden by *TRACE-MACROEXPAND-TRACE-HOOK* & *TRACE-MACROEXPAND-MAYBE-TRACE*
Collect things into a list forwards.
Within the body of this macro The form ‘(COLLECT THING)’ will collect THING into the list returned by COLLECTING. COLLECT is a local function so can be passed as an argument, or returned. COLLECT returns its argument. See WITH-COLLECTORS for which this COLLECTING is now a shim
Collect multiple values withing COLLECTING
COLLECTORS should be the names of bound collectors. If there is a
single other argument this is assumed to be a form which will return
multiple values. There should either be a single form in the body
which is assumed to return multiple values, or exacly as many forms as
there are collectors with one value being collected from each.
Return the values collected.
Define a memoized function.
FNSPEC is either the name of the function (names like (SETF x) are
OK), or a list suitable as an arglist for MEMOIZE-FUNCTION. ARGS &
BOD are passed off to DEFUN.
This will declare FNSPEC NOTINLINE, which may be necessary to prevent good compilers optimizing away self calls & stuff like that.
Define a metatronic compiler macro
This is exactly like DEFINE-COMPILER-MACRO but metatronic symbols are
gensymized, when they occur directly in list structure.
Note that metatronic symbols are *not* gensymized in arrays, structures or what have you as it’s just too hard. Use LOAD-TIME-VALUE to construct a literal at load time if you really need this.
Define a single function.
NAME/OPTIONS is interpreted as DEFINE-FUNCTIONS, which see.
Hairy function-defining form.
NAMES/OPTIONS is a list of specifications for functions. Each element
may be either:
- a function name such as FOO or (SETF FOO);
- a lambda list (function-name &key ftype documentation);
In the second case:
- ftype specifies the function type, which is by default FUNCTION;
- documentation is function documentation (none by default).
If the body of the definition is a single form, this is assumed to return as many values as there are functions to define. Otherwise there should be as many forms in the body as there are functions to define, and the value of each form is used for the corresponding function.
Define a single macro function.
NAME/OPTIONS is interpreted as DEFINE-MACRO-FUNCTIONS, which see.
Hairy macro-function defining form.
NAMES/OPTIONS is a list of specifications for macro functions. Each
element may be either: - a macro name such as FOO or (SETF FOO); - a
lambda list (macro-name &key documentation);
In the second case documentation is macro documentation (none by
default).
If the body of the definition is a single form, this is assumed to return as many values as there are macros to define. Otherwise there should be as many forms in the body as there are functions to define, and the value of each form is used for the corresponding function.
Note that macro functions all take exactly two arguments.
Define a metatronic macro
This is exactly like DEFMACRO but metatronic symbols are gensymized,
when they occur directly in list structure.
Note that metatronic symbols are *not* gensymized in arrays, structures or what have you as it’s just too hard. Use LOAD-TIME-VALUE to construct a literal at load time if you really need this.
Like PASSING but test is inverted and at the end
Like PASSING but test is inverted and at the end, and binding is sequential
Like PASSING, but the test is at the end
LIKE PASSING but bindings are in series and the test is at the end
A variant of DO
This is like DO, but each variable binding may be one of
- <var> which binds the variable to NIL and steps it to its current
value;
- (<var> <init/step>) which binds to value of <init/step> and steps to
value of init/step;
- (<var> <init> <step>) which binds to <init> and steps to value of
<step>.
If no value forms are specified then the current values of the
bindings are returned as multiple values. If more than one value form
is specified then the combined multiple values of all of them are
returned.
This expands into DO, so all the things that are true of DO are true here: the body is a TAGBODY, and there is a block named NIL wrapped around the form so (RETURN ...) will work.
A variant of DO*: see DOING
Like DOLIST but with multiple lists
Each BINDING is either (var init) or (var init value). As many values are returned as bindings with value forms, so this may return between no values and as manu values as bindings. The inits are evaluated in parallel (nothing else really makes much sense). The loop ends when the first list terminates. At least one the of variables will therefore be NIL when the loop terminates (same as for DOLIST, whee the only variable is NIL when the loop terminates).
Bind a local escape function
Within the body of this form, ESCAPE will immediately return from it.
Given arguments it returns those as multiple values. With no
arguments it returns the values of DEFAULTS, or no values if none are
given. The forms in DEFAULTS are not evaluated until and if the
escape function is called with no arguments, and are evaluated in the
lexical contxt of the ESCAPING form, and the dynamic context of the
point the escape function is called.
It won’t work to call the escape function once control has left ESCAPING.
Like PASSING but loop until all the variables become true
Like PASSING, but test is inverted and sequential binding
Scheme-style named-LET: parallel binding
This compiles into LABELS and recursive calls, which is fully general.
If you are using an implementation which can’t optimise tail calls,
start using one which can.
This is like LET, not LET*: initial values can’t see preceeding variables.
Variant Scheme-style named-LET: sequential binding
This compiles into LABELS and recursive calls, which is fully general.
If you are using an implementation which can’t optimise tail calls,
start using one which can.
This is like LET*: initial values can depend on preceeding variables.
Applicative iteration macro with optional step forms: parallel binding
This is like ITERATE but each binding can be (var init/step) or (var
init step). The local function has keyword arguments which default to
init/step or step respectively, so you can provide only some, or
simply use this as a looping construct.
This is like LET or DO, not LET* or DO*: initial values can’t see preceeding variables and step forms see the old values of variables.
Applicative iteration macro with optional step forms: sequentisl binding
This is like ITERATE but each binding can be (var init/step) or (var
init step). The local function has approproate keyword arguments
which default to init/step or step respectively, so you can provide
only some, or simply use this as a looping construct.
This is like LET* or DO*, not LET or DO: initial values can see preceeding variables and step forms can see preceeding updated variables.
A simple loop construct
Each clause in CLAUSES may either be <var> which is bound to NIL, or may be (<var> <init>) which binds <var> to <init>. Each time through the loop the variables are updated by the values of the BODY. The values of the last of the forms in DECLS/FORMS are used to update the variables. There is no termination condition, but the forms are wrapped in a block named NIL in the usual way. Initial variable bindings are in parallel.
Like LOOPING but initial bindings are sequential
Like LOOPING but with multiple values
(looping/values ((<var> ...) <form>) ...) binds the <var>s to the values of <form> and hhen updates them with the values of the last form in the body. (looping/values ((<var> ...) <form> ...) binds the <var>s to the cobined values of all the <form>’s and then updates them with the values of the last form in the body. As with LOOPING there is no termination condition but the body is wrapped in a block named NIL so RETURN will work.
A nested variant of LOOPING/VALUES
Each clause in CLAUSES is of the form either ((<var> ...) <form>), in which case the <var>s will be bound to the multiple values of <form>, or ((<var> ...) <form> ...) which is the same as ((<var>) (multiple-value-call #’values <form> ...)). Each clause happens sequentially, within the scope of bindings established by previous clauses. The total set of the variables is then updated by the values of the last form in the body.
MACROLET, metatronically
A version of LABELS that memoizes the local functions
See MEMOIZE-FUNCTION and DEF-MEMOIZED-FUNCTION. If code that uses this is compiled (either by COMPILE or COMPILE-FILE, then the table of memoized results will be unique, if interpreted then a new table may be generated for each use. The function ‘names’ are generalised in the same way as for DEF-MEMOIZED-FUNCTION.
Loop while some variables are all true
Each clause in CLAUSES is either <var> which is initialised to NIL and
stepped to its current value, (<var> <init/step>) which initialises
<var> to the value of <init/step> and steps it to the current value of
the same form, or (<var> <init> <step>) which splits the two forms.
The variables are bound, in parallel, to the value of the
initialisation forms, and the forms in the body are evaluated while
all the variables remain true, with the variables being updated at the
end of the body. Once one or variables becomes false the loop stops
and the values of the variables (at least one of which will be NIL)
are returned.
This expands into DO, so all the things that are true of DO are true here: the body is a TAGBODY, and there is a block named NIL wrapped around the form so (RETURN ...) will work.
Like PASSING, but with bindings in series
Trace macros named by MACRO-NAMES, when macro tracing is on.
These macros don’t need to be defined: they will be traced when they
are defined. In fact they don’t even need to be macros: if they’re
not then nothing will happen but they won’t ever be traced.
See *TRACE-MACROEXPAND-TRACED-NAMES* etc for the underlying mechanism.
TRACE-MACROEXPAND turns tracing on and off.
You probably want to set *TRACE-MACROEXPAND-TRACED-PACKAGES* to ’() if you use this, or you will get per-package tracing.
Untrace macros named by MACRO-NAMES.
Accumulate some things
This defines some local functions which accumulate things as described
by ACCUMULATORS. Each accumulator is given as either a simple
specification or a more extensible one which allows more options.
A simple specification is (name operator &optional initially), where
name is the name of the local accumulator function, operator names the
operator and initially, if given is the initial value.
operator denotes (it’s a symbol or a lambda expression) a function
which can take zero or two arguments. If there is no initial value
it is called with no arguments to initialise the accumulator.
Otherwise it will be called, each time the accumulator function is
called, with two arguments: the current value of the accumulator and
the argument to the accumulator function. Its return value is the new
value of the accumulator.
The extensible specification is (name operator &key initially type
returner). In this case name, operator & initially mean exactly the
same as previously, but type is a type specification for the variable
which underlies the accumulator, and returner denotes a function of
one argument, the final value of the accumulator, whose return value
is used instead of the final value. There may in future be additional
keywords.
The local accumulator functions are declared inline, and return their
argument.
The form returns the final values of all the accumulators as multiple values, possibly via the returner functions.
Collect some things into lists forwards.
The names in COLLECTORS are defined as local functions, which each
collect into a separate list. The collector functions return their
argument. Returns as many values as there are collectors.
The local functions defined by this macro are declared inline and so should have no overhead for a reasonable compiler. The macro uses secret tail pointers and so should be efficient.
Evaluate FORMS with (or without) macroexpansion tracing
See CALL/MACROEXPAND-TRACING which this is a shim for.
This is exactly like WITH-ACCESSORS but for completely general objects.
For instance:
(with-oject-accessors ((kar car) cdr) (cons 1 2)
... kar ... cdr ...)
Call f with macroexpansion tracing on (or off).
This is useful for compiling files, say, where you want to see what happens.
Clear memoized results for FN-NAME
Clear memoized results for all functions
Collect VALUE into COLLECTOR, returning VALUE.
If COLLECTOR is something made by MAKE-COLLECTOR, do the right thing.
If it is a function (such as the local functions defined by COLLECTING
/ WITH-COLLECTORS), simply call it with the value.
This is the closest equivalent to Interlisp’s TCONC.
Return the contents of a collector
If APPENDING is given, append this to the collector (without copying
it) first. APPENDING does not need to be a proper list or a list at
all: the last cons of the collector will be made to be APPENDING, and
if nothing has been collected previously APPENDING itself will be
returned.
If APPENDING is not given, then the collector can be used after this
but the returned contents will be destructively modified in that case.
If APPENDING is given the collector contents will generally be junk as
the tail pointer is not updated.
See NCONC-COLLECTOR-ONTO for a function which appends a list to a pointer and updates the tail pointer appropriately.
Copy a stringtable
Make a copy of a stringtable: FROM if given is the stringtable to
copy, which by default is *STRINGTABLE*. If FROM is given as NIL then
a copy is made of the initial stringtable. TO is the stringtable to
copy into, if given. if not given a new stringtable is created.
If the third optional argument is not NIL, then don’t copy special
character handlers. In this case the only thing copied is the escape
character.
The argument convention is intentianally the same as COPY-READTABLE, which is why it’s slightly clunky, especially if you don’t want any specials.
Is FN-NAME memoized?
Get the handler function for a stringtable special character
For CHARACTER and SUBCHARACTER return the handler function in
STRINGTABLE (by default *STRINGTABLE*). As a second value return true
if it is not the fallback, false if it is.
An error is signaled if CHARACTER is not a special character in the stringtable.
Is macroexpansion currently traced?
Make a collector object into which things can be collected.
INITIAL-CONTENTS, if given it the initial contents of the object, a
list.
COPY (default true) means that the initial contents will be copied.
If it is false, then the initial contents will be destructively
modified by collection.
The implementation of collectors is unspecified, but they’re obviously just conses with a tail pointer in the cdr. See TCONC in the IRM.
Make a readtable with comment-form readmacro (#; by default).
Make a copy of FROM (defaultly the current readtable) and in it make
#; (or as below) be a read macro which causes the next form to be
skipped. #n; will skip n forms. Other than the skipping-n-forms
thing, this is no more than what #+(or) will do, but it is clearer I
think.
If TO is given, instead copy & modify FROM into TO (this behaviour is
compatible with what COPY-READTABLE does).
If SEMICOLON is given, it is the dispatching character, instead of #\;.
Make a readtable suitable for reading single forms case-sensitively.
Make a copy of FROM (defaultly the current readtable) and in it make
#~ (replacing ~ by the value of TOGGLE if given) be a toggle which
causes the next form to be read case-sensitively. While reading
case-sensitively #~ has the opposite effect: it will cause the next
form to be read case insensitively. So
(let ((*readtable* (make-cs-form-readtable)))
(read-from-string "(one #~(two ThrEE #~four) five)"))
should return (one (|two| |ThrEE| four) five) as its first value.
This all works by having a pair of readtables which are alike apart
from their case sensitivity. Using two readtables rather than
modifying the case-sensitivity of one makes the code far more likely
to be safe, especially in the presence of multiple threads.
A consequence of the secret second readtable is that, if you want
other macro characters in the resulting readtable, you should do so
before copying it.
If #~ is adefined as a dispatch macro in the readtable being copied,
signal an error.
If TO is given, instead copy & modify FROM into TO (this behaviour is
compatible with what COPY-READTABLE does).
If TOGGLE is given, then use it as the toggle character instead of #\~.
Make readtable with read-time package support.
This is a readtable which is a copy of FROM (defaultly the current
readtable), but which has #@ (or as specified below) defined such that
#@pkg will read the next form in the package denoted by pkg. So
(let ((*readtable* (make-cs-form-readtale)))
(read-from-string "(foo #@keyword bar)"))
should return (foo :bar) as its first value.
If #@ is adefined as a dispatch macro in the readtable being copied,
raise an error.
If TO is given, instead copy & modify FROM into TO (this behaviour is
compatible with what COPY-READTABLE does).
If AT is given, it is the dispatch macro character to use instead of #@.
Make a readtable which uses a stringtable for some strings
FROM & TO specify readtables in the same way as COPY-READTABLE.
The stringtable will be attached to the DELIMITER subcharacter of the
# dispatching macro character.
Return the readtable.
Make a special character in a stringtable
CHARACTER is the character to make special. FALLBACK, if given, is
the fallback function for the special character: the default is a
function which simply returns the character following the special
character. STRINGTABLE, if given, is the stringtable to modify: the
default is *STRINGTABLE*. Return T.
This is intentionally similar to MAKE-DISPATCH-MACRO-CHARACTER.
Memoize FN-NAME, a function name, causing its results to be stashed
KEY is a function which is given the arglist of FN-NAME, and should
return a key to hash on for memoizing. TEST is a function which the
test for the ashtable. See Norvig P269-275.
Note this function may not work on self-recursive functions because the compiler can optimize away self-calls in various ways. DEF-MEMOIZED-FUNCTION should work for those cases as it is careful to ensure the function can not be inlined like this.
Return a metatronic version of FORM, the table of variables, a list
of anonymous variables and the sharing table.
Arguments are FORM with keyword arguments
- REWRITES is a table of variables returned from a previous call
- SHARES is a sharing table returned from a previous call
- REWRITER, if given, should be a designator for a function of one
argument, a symbol, which should either return the symbol or a
metatronized symbol and an indication of whether it should be stored
in the rewrite table. The default value of REWRITER is
*DEFAULT-METATRONIZE-SYMBOL-REWRITER*.
This only looks at list structure. Sharing and circularity of list structure (only) is correctly copied.
Append ONTO to the end of COLLECTOR, uodating the tail pointer
This does not copy ONTO, so it will be modified if any more elements
are collected into COLLECTOR. Takes time proportional to the length
of ONTO.
Return the collector.
Destructively concatenate one or more collectors, returning the first
All the collectors share a tail pointer after this is done, while their head pointers point at appropriate points on the NCONCed list. You can then collect more into any one of them but this will make the tail pointers of all the others junk.
Parse a body that may have a docstring at the start
Return three values: the docstring, or NIL, a list of declarations and a list of forms.
Parse a body which can not have a docstring
Return two values: a list of declarations and a list of forms
Read a string with a stringtable
DELIMITER is the delimiter which terminates the string. FROM is the stream to read, by default *STANDARD-INPUT*, STRINGTABLE is the stringtable to use, default *STRINGTABLE*. Return the string.
Reset, or check, the precision time offsets.
Returns four values: a universal time and the internal time at which
point the second ticked, and the previous values for these two. By
default this also sets the internal variables to the new values.
If REPORT-ONLY is given as NIL this will not reset the internal values
but only return them.
TRIES (default 3) is the number of attempts to make to get this right.
There will be a warning if more than one try is needed, and an error
if more than TRIES is needed.
This function necessarily takes at least a second to run.
Set STRINGTABLE to have a newline skipper
Add a special handler for STRINGTABLE (default *STRINGTABLE*) which will eat a newline and any number of whitespace characters. SPECIAL-CHARACTER is the special character in STRINGTABLE, which is #~ by default. If WHITE-WARNERS is true (by default) also add some handlers for whitespace which merely warn. This helps detect the case of, for instance, ’~ ’ at the end of a line. Return the stringtable.
Set the handler function for a stringtable special character
For CHARACTER and SUBCHARACTER set FUNCTION as the handler in
STRINGABLE (by default *STRINGTABLE*). Return T.
An error is signaled if CHARACTER is not a special character in the stringtable.
Trace macros in the packages in PACKAGE-DESIGNATORS
See *TRACE-MACROEXPAND-TRACED-PACKAGES* for details of what a package
designator means in this context. Return the list of all package
designators.
Note this is a function, not a macro like TRACE-MACRO / TRACE
Trace or untrace macroexpansion.
If called with no argument, or an argument which is true, ensure that
macroexpansion is on. Otherwise ensure it is off.
Return the previous state.
Remove memoization for FN-NAME
Unmemoize all functions
Untrace macros in the packages in PACKAGE-DESIGNATORS
See *TRACE-MACROEXPAND-TRACED-PACKAGES* for details of what a package
designator means in this context. Return the list of all package
designators.
Note this is a function, not a macro like UNTRACE-MACRO / UNTRACE
once-only-log-entry) &key) ¶singleton-class) &key) ¶abstract-class) &rest junk) ¶singleton-class) &key) ¶stringtable) stream) ¶standard-class) (superclass final-class)) ¶sb-mop.
final-class) (superclass standard-class)) ¶sb-mop.
standard-class) (superclass abstract-class)) ¶sb-mop.
abstract-class) (superclass standard-class)) ¶sb-mop.
standard-class) (superclass singleton-class)) ¶sb-mop.
singleton-class) (superclass singleton-class)) ¶sb-mop.
singleton-class) (superclass standard-class)) ¶sb-mop.
all SLOG condition types inherit from this
condition.
(quote (get-internal-real-time))
This slot is read-only.
class of log entries which are logged once only
(quote (cons nil nil))
This slot is read-only.
simple SLOG condition
log-entry.
simple-condition.
The class of abstract classes
standard-class.
The class of classes which may not be subclassed
standard-class.
standard-class.
The default symbol rewriter used by METATRONIZE
The initial value of this implements the bahviour described in the documentation: changing it will change the behaviour or DEFMACRO/M and MACROLET/M
once-only-log-entry)) ¶once-only-log-entry)) ¶once-only-log-entry)) ¶stringtable-error)) ¶simple-error.
simple-warning.
style-warning.
simple-error.
(quote "stringtable error")
This slot is read-only.
reader-error.
stringtable-error.
(quote "stringtable reader error")
| Jump to: | (
A B C D E F G H I L M N O P R S T U V W |
|---|
| Jump to: | (
A B C D E F G H I L M N O P R S T U V W |
|---|
| Jump to: | *
C D E I L M P S |
|---|
| Jump to: | *
C D E I L M P S |
|---|
| Jump to: | A B C D F H I L M O P R S T U W |
|---|
| Jump to: | A B C D F H I L M O P R S T U W |
|---|