The misc-extensions Reference Manual

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.

Table of Contents


1 Introduction


2 Systems

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


2.1 misc-extensions

The GMap iteration macro, plus a few other useful macros.

Author

Scott L. Burson <>

Home Page

https://github.com/slburson/misc-extensions

Source Control

https://github.com/slburson/misc-extensions

License

Public domain

Version

4.0.6

Source

misc-extensions.asd.

Child Component

src (module).


3 Modules

Modules are listed depth-first from the system components tree.


3.1 misc-extensions/src

Source

misc-extensions.asd.

Parent Component

misc-extensions (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 misc-extensions/misc-extensions.asd

Source

misc-extensions.asd.

Parent Component

misc-extensions (system).

ASDF Systems

misc-extensions.


4.1.3 misc-extensions/src/new-let.lisp

Dependency

defs.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.4 misc-extensions/src/gmap.lisp

Dependency

new-let.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.5 misc-extensions/src/fn.lisp

Dependency

gmap.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Public Interface

fn (macro).


4.1.6 misc-extensions/src/tests.lisp

Dependency

fn.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Internals

4.1.7 misc-extensions/src/rev-fun-bind.lisp

Dependency

tests.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Public Interface

4.1.8 misc-extensions/src/define-class.lisp

Dependency

rev-fun-bind.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.9 misc-extensions/src/contexts.lisp

Dependency

define-class.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Public Interface
Internals

4.1.10 misc-extensions/src/context-tests.lisp

Dependency

contexts.lisp (file).

Source

misc-extensions.asd.

Parent Component

src (module).

Internals

5 Packages

Packages are listed by definition order.


5.1 misc-extensions.define-class

Source

defs.lisp.

Use List

common-lisp.

Public Interface
Internals

5.2 misc-extensions.lexical-contexts

Source

defs.lisp.

Nickname

lexical-contexts

Use List

common-lisp.

Public Interface
Internals

5.3 misc-extensions.new-let

Source

defs.lisp.

Nickname

new-let

Use List

common-lisp.

Public Interface
Internals

5.4 misc-extensions.gmap

Source

defs.lisp.

Nickname

gmap

Use List

common-lisp.

Public Interface
Internals

5.5 misc-extensions.rev-fun-bind

Source

defs.lisp.

Nickname

rev-fun-bind

Use List

common-lisp.

Public Interface

6 Definitions

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


6.1 Public Interface


6.1.1 Macros

Macro: bcond (&rest clauses)

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).

Package

misc-extensions.new-let.

Source

new-let.lisp.

Macro: cond (&rest clauses)

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).

Package

misc-extensions.new-let.

Source

new-let.lisp.

Macro: def-arg-type (name args &body body)

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.

Package

misc-extensions.gmap.

Source

gmap.lisp.

Macro: def-gmap-arg-type (name args &body body)

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 ...)’.

Package

misc-extensions.gmap.

Source

gmap.lisp.

Macro: def-gmap-res-type (name args &body body)

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 ...)’.

Package

misc-extensions.gmap.

Source

gmap.lisp.

Macro: def-result-type (name args &body body)

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.

Package

misc-extensions.gmap.

Source

gmap.lisp.

Macro: defcontext (context-name parameter-list &body body)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Macro: define-class (class-name superclasses slot-specs &body class-options)

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’.")))

Package

misc-extensions.define-class.

Source

define-class.lisp.

Macro: deflex (var &optional val doc)

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.

Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Macro: deflex-reinit (var val &optional doc)

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.

Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Macro: fn (lambda-list &body body)

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.

Package

misc-extensions.new-let.

Source

fn.lisp.

Macro: gmap (res-spec fn &rest arg-specs)

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’).

Package

misc-extensions.gmap.

Source

gmap.lisp.

Macro: isetq (&rest var-val-pairs)

"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!!!

Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Macro: let (clauses &body body)

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.

Package

misc-extensions.new-let.

Source

new-let.lisp.

Macro: nlet (clauses &body body)

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.

Package

misc-extensions.new-let.

Source

new-let.lisp.

Macro: rflet (value-form &body clauses)

Just like ‘flet’ except that the first subform is the form that computes the value, and the remaining subforms are the binding clauses.

Package

misc-extensions.rev-fun-bind.

Source

rev-fun-bind.lisp.

Macro: rlabels (value-form &body clauses)

Just like ‘labels’ except that the first subform is the form that computes the value, and the remaining subforms are the binding clauses.

Package

misc-extensions.rev-fun-bind.

Source

rev-fun-bind.lisp.

Macro: rmacrolet (value-form &body clauses)

Just like ‘macrolet’ except that the first subform is the form that computes the value, and the remaining subforms are the binding clauses.

Package

misc-extensions.rev-fun-bind.

Source

rev-fun-bind.lisp.

Macro: with-context (context-invocation &body body)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Macro: with-contexts (context-invocations &body body)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.


6.1.2 Ordinary functions

Function: add-define-class-extension (option ext-fn)

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.

Package

misc-extensions.define-class.

Source

define-class.lisp.

Function: copy-gmap-type (from-symbol to-symbol)

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.

Package

misc-extensions.gmap.

Source

gmap.lisp.


6.1.3 Standalone methods

Method: make-load-form ((ctxt context) &optional environment)
Source

contexts.lisp.


6.2 Internals


6.2.1 Constants

Constant: context-instance-default-element

An attempt to give the user a clue if they run into this.

Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.


6.2.2 Special variables

Special Variable: *gmap-arg-type-list*

A list of all GMAP arg types that have been defined.

Package

misc-extensions.gmap.

Source

gmap.lisp.

Special Variable: *gmap-result-type-list*

A list of all GMAP result types that have been defined.

Package

misc-extensions.gmap.

Source

gmap.lisp.

Special Variable: *tab-width*
Package

misc-extensions.define-class.

Source

define-class.lisp.


6.2.3 Ordinary functions

Function: analyze-decls (clauses body)

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.

Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: bcond-build-clause (let-sym let-clauses pred consequents block-nm)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: bcond-clause (clause block-nm)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: bound-decls (decls vars)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Reader: context-all-fns (instance)
Writer: (setf context-all-fns) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

all-fns.

Reader: context-all-vars (instance)
Writer: (setf context-all-vars) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

all-vars.

Reader: context-bind-fns (instance)
Writer: (setf context-bind-fns) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

bind-fns.

Reader: context-bind-vars (instance)
Writer: (setf context-bind-vars) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

bind-vars.

Reader: context-constructor (instance)
Writer: (setf context-constructor) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

constructor.

Reader: context-macros (instance)
Writer: (setf context-macros) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

macros.

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

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

name.

Function: context-p (object)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Reader: context-parameter-list (instance)
Writer: (setf context-parameter-list) (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Target Slot

parameter-list.

Function: copy-context (instance)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Function: expand-new-let (clauses body decls)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: gmap>arg-spec-lookup (raw-arg-spec)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>expand (fn res-specs arg-specs)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>funcall (function &rest args)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>let-specs (arg-specs res-specs)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>param (arg-spec)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>param>arg (param arg-spec multi-vars)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>param>exit-test (param arg-spec)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>param>multi-let-specs (param arg-spec multi-vars)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>param>multi-vars (arg-spec)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>res-spec-lookup (raw-res-spec)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>res-spec-lookup-1 (raw-res-spec)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>res>cleanup (res-specs result-list one-value-p)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>res>init-clauses (res-specs)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: gmap>res>next (res-spec result fnvals)
Package

misc-extensions.gmap.

Source

gmap.lisp.

Function: make-context (name parameter-list constructor &optional bind-vars bind-fns all-vars all-fns macros)
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Function: new-let-bound-vars (clauses)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: prune-decls (decls vars)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: remove-indentation (str)

De-indents the second and subsequent lines of ‘str’ by an amount equal to the minimum indentation of those lines.

Package

misc-extensions.define-class.

Source

define-class.lisp.

Function: split-level (clauses this-level-single this-level-multiple next-level)
Package

misc-extensions.new-let.

Source

new-let.lisp.

Function: test-context-0 ()
Package

misc-extensions.lexical-contexts.

Source

context-tests.lisp.

Function: test-context-1 ()
Package

misc-extensions.lexical-contexts.

Source

context-tests.lisp.

Function: test-context-2 ()
Package

misc-extensions.lexical-contexts.

Source

context-tests.lisp.

Function: test-contexts ()
Package

misc-extensions.lexical-contexts.

Source

context-tests.lisp.

Function: test-new-syntax ()
Package

misc-extensions.gmap.

Source

tests.lisp.

Function: test-old-syntax ()
Package

misc-extensions.gmap.

Source

tests.lisp.

Function: type-specifier-name? (x)
Package

misc-extensions.new-let.

Source

new-let.lisp.


6.2.4 Generic functions

Generic Reader: kind (condition)
Package

misc-extensions.gmap.

Methods
Reader Method: kind ((condition keyword-name-deprecated))
Source

gmap.lisp.

Target Slot

kind.

Generic Reader: name (condition)
Package

misc-extensions.gmap.

Methods
Reader Method: name ((condition keyword-name-deprecated))
Source

gmap.lisp.

Target Slot

name.


6.2.5 Conditions

Condition: keyword-name-deprecated
Package

misc-extensions.gmap.

Source

gmap.lisp.

Direct superclasses

style-warning.

Direct methods
Direct slots
Slot: kind

One of { :arg, :res }.

Initargs

:kind

Readers

kind.

Writers

This slot is read-only.

Slot: name
Initargs

:name

Readers

name.

Writers

This slot is read-only.


6.2.6 Structures

Structure: context
Package

misc-extensions.lexical-contexts.

Source

contexts.lisp.

Direct superclasses

structure-object.

Direct methods

make-load-form.

Direct slots
Slot: name
Readers

context-name.

Writers

(setf context-name).

Slot: parameter-list
Readers

context-parameter-list.

Writers

(setf context-parameter-list).

Slot: constructor
Readers

context-constructor.

Writers

(setf context-constructor).

Slot: bind-vars
Readers

context-bind-vars.

Writers

(setf context-bind-vars).

Slot: bind-fns
Readers

context-bind-fns.

Writers

(setf context-bind-fns).

Slot: all-vars
Readers

context-all-vars.

Writers

(setf context-all-vars).

Slot: all-fns
Readers

context-all-fns.

Writers

(setf context-all-fns).

Slot: macros
Readers

context-macros.

Writers

(setf context-macros).


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   I   K   L   M   N   P   R   S   T   W  
Index Entry  Section

(
(setf context-all-fns): Private ordinary functions
(setf context-all-vars): Private ordinary functions
(setf context-bind-fns): Private ordinary functions
(setf context-bind-vars): Private ordinary functions
(setf context-constructor): Private ordinary functions
(setf context-macros): Private ordinary functions
(setf context-name): Private ordinary functions
(setf context-parameter-list): Private ordinary functions

A
add-define-class-extension: Public ordinary functions
analyze-decls: Private ordinary functions

B
bcond: Public macros
bcond-build-clause: Private ordinary functions
bcond-clause: Private ordinary functions
bound-decls: Private ordinary functions

C
cond: Public macros
context-all-fns: Private ordinary functions
context-all-vars: Private ordinary functions
context-bind-fns: Private ordinary functions
context-bind-vars: Private ordinary functions
context-constructor: Private ordinary functions
context-macros: Private ordinary functions
context-name: Private ordinary functions
context-p: Private ordinary functions
context-parameter-list: Private ordinary functions
copy-context: Private ordinary functions
copy-gmap-type: Public ordinary functions

D
def-arg-type: Public macros
def-gmap-arg-type: Public macros
def-gmap-res-type: Public macros
def-result-type: Public macros
defcontext: Public macros
define-class: Public macros
deflex: Public macros
deflex-reinit: Public macros

E
expand-new-let: Private ordinary functions

F
fn: Public macros
Function, (setf context-all-fns): Private ordinary functions
Function, (setf context-all-vars): Private ordinary functions
Function, (setf context-bind-fns): Private ordinary functions
Function, (setf context-bind-vars): Private ordinary functions
Function, (setf context-constructor): Private ordinary functions
Function, (setf context-macros): Private ordinary functions
Function, (setf context-name): Private ordinary functions
Function, (setf context-parameter-list): Private ordinary functions
Function, add-define-class-extension: Public ordinary functions
Function, analyze-decls: Private ordinary functions
Function, bcond-build-clause: Private ordinary functions
Function, bcond-clause: Private ordinary functions
Function, bound-decls: Private ordinary functions
Function, context-all-fns: Private ordinary functions
Function, context-all-vars: Private ordinary functions
Function, context-bind-fns: Private ordinary functions
Function, context-bind-vars: Private ordinary functions
Function, context-constructor: Private ordinary functions
Function, context-macros: Private ordinary functions
Function, context-name: Private ordinary functions
Function, context-p: Private ordinary functions
Function, context-parameter-list: Private ordinary functions
Function, copy-context: Private ordinary functions
Function, copy-gmap-type: Public ordinary functions
Function, expand-new-let: Private ordinary functions
Function, gmap>arg-spec-lookup: Private ordinary functions
Function, gmap>expand: Private ordinary functions
Function, gmap>funcall: Private ordinary functions
Function, gmap>let-specs: Private ordinary functions
Function, gmap>param: Private ordinary functions
Function, gmap>param>arg: Private ordinary functions
Function, gmap>param>exit-test: Private ordinary functions
Function, gmap>param>multi-let-specs: Private ordinary functions
Function, gmap>param>multi-vars: Private ordinary functions
Function, gmap>res-spec-lookup: Private ordinary functions
Function, gmap>res-spec-lookup-1: Private ordinary functions
Function, gmap>res>cleanup: Private ordinary functions
Function, gmap>res>init-clauses: Private ordinary functions
Function, gmap>res>next: Private ordinary functions
Function, make-context: Private ordinary functions
Function, new-let-bound-vars: Private ordinary functions
Function, prune-decls: Private ordinary functions
Function, remove-indentation: Private ordinary functions
Function, split-level: Private ordinary functions
Function, test-context-0: Private ordinary functions
Function, test-context-1: Private ordinary functions
Function, test-context-2: Private ordinary functions
Function, test-contexts: Private ordinary functions
Function, test-new-syntax: Private ordinary functions
Function, test-old-syntax: Private ordinary functions
Function, type-specifier-name?: Private ordinary functions

G
Generic Function, kind: Private generic functions
Generic Function, name: Private generic functions
gmap: Public macros
gmap>arg-spec-lookup: Private ordinary functions
gmap>expand: Private ordinary functions
gmap>funcall: Private ordinary functions
gmap>let-specs: Private ordinary functions
gmap>param: Private ordinary functions
gmap>param>arg: Private ordinary functions
gmap>param>exit-test: Private ordinary functions
gmap>param>multi-let-specs: Private ordinary functions
gmap>param>multi-vars: Private ordinary functions
gmap>res-spec-lookup: Private ordinary functions
gmap>res-spec-lookup-1: Private ordinary functions
gmap>res>cleanup: Private ordinary functions
gmap>res>init-clauses: Private ordinary functions
gmap>res>next: Private ordinary functions

I
isetq: Public macros

K
kind: Private generic functions
kind: Private generic functions

L
let: Public macros

M
Macro, bcond: Public macros
Macro, cond: Public macros
Macro, def-arg-type: Public macros
Macro, def-gmap-arg-type: Public macros
Macro, def-gmap-res-type: Public macros
Macro, def-result-type: Public macros
Macro, defcontext: Public macros
Macro, define-class: Public macros
Macro, deflex: Public macros
Macro, deflex-reinit: Public macros
Macro, fn: Public macros
Macro, gmap: Public macros
Macro, isetq: Public macros
Macro, let: Public macros
Macro, nlet: Public macros
Macro, rflet: Public macros
Macro, rlabels: Public macros
Macro, rmacrolet: Public macros
Macro, with-context: Public macros
Macro, with-contexts: Public macros
make-context: Private ordinary functions
make-load-form: Public standalone methods
Method, kind: Private generic functions
Method, make-load-form: Public standalone methods
Method, name: Private generic functions

N
name: Private generic functions
name: Private generic functions
new-let-bound-vars: Private ordinary functions
nlet: Public macros

P
prune-decls: Private ordinary functions

R
remove-indentation: Private ordinary functions
rflet: Public macros
rlabels: Public macros
rmacrolet: Public macros

S
split-level: Private ordinary functions

T
test-context-0: Private ordinary functions
test-context-1: Private ordinary functions
test-context-2: Private ordinary functions
test-contexts: Private ordinary functions
test-new-syntax: Private ordinary functions
test-old-syntax: Private ordinary functions
type-specifier-name?: Private ordinary functions

W
with-context: Public macros
with-contexts: Public macros


A.4 Data types

Jump to:   C   D   F   G   K   M   N   P   R   S   T  
Index Entry  Section

C
Condition, keyword-name-deprecated: Private conditions
context: Private structures
context-tests.lisp: The misc-extensions/src/context-tests․lisp file
contexts.lisp: The misc-extensions/src/contexts․lisp file

D
define-class.lisp: The misc-extensions/src/define-class․lisp file
defs.lisp: The misc-extensions/src/defs․lisp file

F
File, context-tests.lisp: The misc-extensions/src/context-tests․lisp file
File, contexts.lisp: The misc-extensions/src/contexts․lisp file
File, define-class.lisp: The misc-extensions/src/define-class․lisp file
File, defs.lisp: The misc-extensions/src/defs․lisp file
File, fn.lisp: The misc-extensions/src/fn․lisp file
File, gmap.lisp: The misc-extensions/src/gmap․lisp file
File, misc-extensions.asd: The misc-extensions/misc-extensions․asd file
File, new-let.lisp: The misc-extensions/src/new-let․lisp file
File, rev-fun-bind.lisp: The misc-extensions/src/rev-fun-bind․lisp file
File, tests.lisp: The misc-extensions/src/tests․lisp file
fn.lisp: The misc-extensions/src/fn․lisp file

G
gmap.lisp: The misc-extensions/src/gmap․lisp file

K
keyword-name-deprecated: Private conditions

M
misc-extensions: The misc-extensions system
misc-extensions.asd: The misc-extensions/misc-extensions․asd file
misc-extensions.define-class: The misc-extensions․define-class package
misc-extensions.gmap: The misc-extensions․gmap package
misc-extensions.lexical-contexts: The misc-extensions․lexical-contexts package
misc-extensions.new-let: The misc-extensions․new-let package
misc-extensions.rev-fun-bind: The misc-extensions․rev-fun-bind package
Module, src: The misc-extensions/src module

N
new-let.lisp: The misc-extensions/src/new-let․lisp file

P
Package, misc-extensions.define-class: The misc-extensions․define-class package
Package, misc-extensions.gmap: The misc-extensions․gmap package
Package, misc-extensions.lexical-contexts: The misc-extensions․lexical-contexts package
Package, misc-extensions.new-let: The misc-extensions․new-let package
Package, misc-extensions.rev-fun-bind: The misc-extensions․rev-fun-bind package

R
rev-fun-bind.lisp: The misc-extensions/src/rev-fun-bind․lisp file

S
src: The misc-extensions/src module
Structure, context: Private structures
System, misc-extensions: The misc-extensions system

T
tests.lisp: The misc-extensions/src/tests․lisp file