CLOSER-MOP - Closer Mop

Download
The CLOSER-MOP dictionary
Acknowledgements

Download

CLOSER-MOP together with this documentation can be downloaded from http://weitz.de/files/closer-mop.tar.gz. The current version is 0.1.0.

The CLOSER-MOP dictionary

[Generic function]
accessor-method-slot-definition standard-accessor-method => result

[Method]
accessor-method-slot-definition (standard-accessor-method standard-accessor-method) => result

[Generic function]
add-dependent metaobject dependent => result

[Method]
add-dependent (metaobject dependent-update-mixin) dependent => result

[Generic function]
add-direct-method specializer method => result

[Method]
add-direct-method (specializer specializer) method => result :around

[Method]
add-direct-method (specializer class) (method method) => result

[Method]
add-direct-method (specializer specializer-with-object) (method method) => result

[Generic function]
add-direct-subclass class subclass => result

[Method]
add-direct-subclass (class class) (subclass class) => result

[Standard class]
built-in-class

[Standard class]
class

[Generic function]
class-default-initargs class => result

[Method]
class-default-initargs (class slot-class) => result

[Method]
class-default-initargs (class built-in-class) => result

[Method]
class-default-initargs (class forward-referenced-class) => result

[Generic function]
class-direct-default-initargs class => result

[Method]
class-direct-default-initargs (class slot-class) => result

[Method]
class-direct-default-initargs (class built-in-class) => result

[Method]
class-direct-default-initargs (class forward-referenced-class) => result

[Generic accessor]
class-direct-slots class => result
(setf (class-direct-slots slot-class) new-value)

[Method]
class-direct-slots (class slot-class) => result

[Method]
class-direct-slots (class built-in-class) => result

[Method]
class-direct-slots (class forward-referenced-class) => result

[Generic function]
class-direct-subclasses class => result

[Method]
class-direct-subclasses (class class) => result

[Generic function]
class-direct-superclasses class => result

[Method]
class-direct-superclasses (class class) => result

[Generic function]
class-finalized-p class => result

[Method]
class-finalized-p (class class) => result

[Generic function]
class-precedence-list pcl-class => result

[Method]
class-precedence-list (pcl-class pcl-class) => result

[Method]
class-precedence-list (pcl-class forward-referenced-class) => result

[Generic function]
class-prototype class => result

[Method]
class-prototype (class pcl-class) => result

[Method]
class-prototype class :before

[Method]
class-prototype (class std-class) => result

[Method]
class-prototype (class condition-class) => result

[Method]
class-prototype (class structure-class) => result

[Generic accessor]
class-slots class => result
(setf (class-slots slot-class) new-value)

[Method]
class-slots (class slot-class) => result

[Method]
class-slots (class slot-class) :before

[Method]
class-slots (class built-in-class) => result

[Method]
class-slots (class forward-referenced-class) => result

[Generic function]
classp object => result

[Method]
classp object => result

[Method]
classp (object class) => result

[Generic function]
compute-applicable-methods-using-classes generic-function classes => result

[Method]
compute-applicable-methods-using-classes (generic-function generic-function) classes => result

[Generic function]
compute-class-precedence-list root => result

[Method]
compute-class-precedence-list (root class) => result

[Generic function]
compute-default-initargs class => result

[Method]
compute-default-initargs (class slot-class) => result

[Generic function]
compute-discriminating-function gf => result

[Method]
compute-discriminating-function (gf standard-generic-function) => result

[Generic function]
compute-effective-method generic-function combin applicable-methods => result

[Method]
compute-effective-method (generic-function generic-function) (combin long-method-combination) applicable-methods => result

[Method]
compute-effective-method (generic-function generic-function) (combin short-method-combination) applicable-methods => result

[Method]
compute-effective-method (generic-function generic-function) (combin standard-method-combination) applicable-methods => result

[Generic function]
compute-effective-method-function gf effective-method options => result

[Method]
compute-effective-method-function (gf generic-function) effective-method options => result

[Generic function]
compute-effective-slot-definition class name dslotds => result

[Method]
compute-effective-slot-definition (class condition-class) name dslotds => result

[Method]
compute-effective-slot-definition (class slot-class) name dslotds => result

[Generic function]
compute-slots class => result

[Method]
compute-slots (class condition-class) => result

[Method]
compute-slots (class condition-class) => result :around

[Method]
compute-slots (class standard-class) => result

[Method]
compute-slots (class funcallable-standard-class) => result

[Method]
compute-slots (class standard-class) => result :around

[Method]
compute-slots (class funcallable-standard-class) => result :around

[Method]
compute-slots (class structure-class) => result

[Method]
compute-slots (class structure-class) => result :around

[Macro]
defclass &environment env name direct-superclasses direct-slots &rest options => result

[Macro]
defgeneric &whole form name &rest declaration* statement* => result

[Macro]
define-method-combination &whole form &rest args => result

[Macro]
defmethod &whole form name declaration* statement* &environment env => result

[Standard class]
direct-slot-definition

[Generic function]
direct-slot-definition-class class &rest initargs => result

[Method]
direct-slot-definition-class (class condition-class) &rest initargs => result

[Method]
direct-slot-definition-class (class structure-class) &rest initargs => result

[Method]
direct-slot-definition-class (class std-class) &rest initargs => result

[Standard class]
effective-slot-definition

[Generic function]
effective-slot-definition-class class &rest initargs => result

[Method]
effective-slot-definition-class (class condition-class) &rest initargs => result

[Method]
effective-slot-definition-class (class std-class) &rest initargs => result

[Method]
effective-slot-definition-class (class structure-class) &rest initargs => result

[Function]
ensure-class name &rest args => result

[Generic function]
ensure-class-using-class class name &rest args &allow-other-keys => result

[Method]
ensure-class-using-class (class null) name &rest args &allow-other-keys => result

[Method]
ensure-class-using-class (class pcl-class) name &rest args &allow-other-keys => result

[Function]
ensure-finalized class &optional errorp => result

[Function]
ensure-generic-function fun-name &rest all-keys &key environment source-location &allow-other-keys => result

[Generic function]
ensure-generic-function-using-class generic-function fun-name &key environment generic-function-class &allow-other-keys => result

[Method]
ensure-generic-function-using-class (generic-function null) fun-name &key environment generic-function-class &allow-other-keys => result

[Method]
ensure-generic-function-using-class (generic-function generic-function) fun-name &key environment generic-function-class &allow-other-keys => result

[Function]
ensure-method gf lambda-expression &key method-class qualifiers lambda-list specializers => result

[Standard class]
eql-specializer

[Generic function]
eql-specializer-object eql-specializer => result

[Method]
eql-specializer-object (eql-specializer eql-specializer) => result

[Function]
extract-lambda-list specialized-lambda-list => result

[Function]
extract-specializer-names specialized-lambda-list => result

[Generic function]
finalize-inheritance class => result

[Method]
finalize-inheritance (class condition-class) => result

[Method]
finalize-inheritance (class structure-class) => result

[Method]
finalize-inheritance (class std-class) => result

[Method]
finalize-inheritance (class forward-referenced-class) => result

[Generic function]
find-method-combination generic-function type options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql progn)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql or)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql nconc)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql min)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql max)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql list)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql append)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql and)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql +)) options => result

[Method]
find-method-combination (generic-function generic-function) (type (eql standard)) options => result

[Function]
fix-slot-initargs initargs => result

[Standard class]
forward-referenced-class

[Standard class]
funcallable-standard-class

[Accessor]
funcallable-standard-instance-access instance location => result
(setf (funcallable-standard-instance-access instance location) new-value)

[Standard class]
funcallable-standard-object

[Standard class]
generic-function

[Generic function]
generic-function-argument-precedence-order gf => result

[Method]
generic-function-argument-precedence-order (gf standard-generic-function) => result

[Generic accessor]
generic-function-declarations standard-generic-function => result
(setf (generic-function-declarations standard-generic-function) new-value)

[Specialized accessor]
generic-function-declarations (standard-generic-function standard-generic-function) => result
(setf (generic-function-declarations (standard-generic-function standard-generic-function)) new-value)

[Generic function]
generic-function-lambda-list gf => result

[Method]
generic-function-lambda-list (gf generic-function) => result

[Generic accessor]
generic-function-method-class standard-generic-function => result
(setf (generic-function-method-class standard-generic-function) new-value)

[Specialized accessor]
generic-function-method-class (standard-generic-function standard-generic-function) => result
(setf (generic-function-method-class (standard-generic-function standard-generic-function)) new-value)

[Generic accessor]
generic-function-method-combination standard-generic-function => result
(setf (generic-function-method-combination standard-generic-function) new-value)

[Specialized accessor]
generic-function-method-combination (standard-generic-function standard-generic-function) => result
(setf (generic-function-method-combination (standard-generic-function standard-generic-function)) new-value)

[Generic accessor]
generic-function-methods standard-generic-function => result
(setf (generic-function-methods standard-generic-function) new-value)

[Specialized accessor]
generic-function-methods (standard-generic-function standard-generic-function) => result
(setf (generic-function-methods (standard-generic-function standard-generic-function)) new-value)

[Generic accessor]
generic-function-name standard-generic-function => result
(setf (generic-function-name standard-generic-function) new-value)

[Method]
generic-function-name (standard-generic-function standard-generic-function) => result

[Function]
intern-eql-specializer object => result

[Generic function]
make-method-lambda proto-generic-function proto-method lambda-expression environment => result

[Method]
make-method-lambda (proto-generic-function standard-generic-function) (proto-method standard-method) lambda-expression environment => result

[Generic function]
map-dependents metaobject function => result

[Method]
map-dependents (metaobject dependent-update-mixin) function => result

[Standard class]
metaobject

[Standard class]
method

[Standard class]
method-combination

[Generic function]
method-function method => result

[Method]
method-function (method standard-method) => result

[Generic accessor]
method-generic-function standard-method => result
(setf (method-generic-function standard-method) new-value)

[Specialized accessor]
method-generic-function (standard-method standard-method) => result
(setf (method-generic-function (standard-method standard-method)) new-value)

[Generic function]
method-lambda-list m => result

[Method]
method-lambda-list (m standard-method) => result

[Generic function]
method-specializers m => result

[Method]
method-specializers (m standard-method) => result

[Generic function]
reader-method-class class direct-slot &rest initargs => result

[Method]
reader-method-class (class slot-class) direct-slot &rest initargs => result

[Generic function]
remove-dependent metaobject dependent => result

[Method]
remove-dependent (metaobject dependent-update-mixin) dependent => result

[Generic function]
remove-direct-method specializer method => result

[Method]
remove-direct-method (specializer specializer) method => result :around

[Method]
remove-direct-method (specializer class) (method method) => result

[Method]
remove-direct-method (specializer specializer-with-object) (method method) => result

[Generic function]
remove-direct-subclass class subclass => result

[Method]
remove-direct-subclass (class class) (subclass class) => result

[Function]
required-args lambda-list &optional collector => result

[Function]
set-funcallable-instance-function fin new-value => result

[Generic function]
slot-boundp-using-class class object slotd => result

[Method]
slot-boundp-using-class (class std-class) (object standard-object) (slotd standard-effective-slot-definition) => result

[Method]
slot-boundp-using-class (class condition-class) (object condition) (slotd condition-effective-slot-definition) => result

[Method]
slot-boundp-using-class (class structure-class) (object structure-object) (slotd structure-effective-slot-definition) => result

[Standard class]
slot-definition

[Generic accessor]
slot-definition-allocation slotd => result
(setf (slot-definition-allocation standard-slot-definition) new-value)

[Specialized accessor]
slot-definition-allocation (slotd condition-slot-definition) => result
(setf (slot-definition-allocation (standard-slot-definition condition-slot-definition)) new-value)

[Specialized accessor]
slot-definition-allocation (slotd standard-slot-definition) => result
(setf (slot-definition-allocation (standard-slot-definition standard-slot-definition)) new-value)

[Method]
slot-definition-allocation (slotd structure-slot-definition) => result

[Generic accessor]
slot-definition-initargs slot-definition => result
(setf (slot-definition-initargs slot-definition) new-value)

[Specialized accessor]
slot-definition-initargs (slot-definition slot-definition) => result
(setf (slot-definition-initargs (slot-definition slot-definition)) new-value)

[Generic accessor]
slot-definition-initform slot-definition => result
(setf (slot-definition-initform slot-definition) new-value)

[Specialized accessor]
slot-definition-initform (slot-definition slot-definition) => result
(setf (slot-definition-initform (slot-definition slot-definition)) new-value)

[Generic accessor]
slot-definition-initfunction slot-definition => result
(setf (slot-definition-initfunction slot-definition) new-value)

[Specialized accessor]
slot-definition-initfunction (slot-definition slot-definition) => result
(setf (slot-definition-initfunction (slot-definition slot-definition)) new-value)

[Generic accessor]
slot-definition-location standard-effective-slot-definition => result
(setf (slot-definition-location standard-effective-slot-definition) new-value)

[Specialized accessor]
slot-definition-location (standard-effective-slot-definition standard-effective-slot-definition) => result
(setf (slot-definition-location (standard-effective-slot-definition standard-effective-slot-definition)) new-value)

[Generic accessor]
slot-definition-name slot-definition => result
(setf (slot-definition-name slot-definition) new-value)

[Specialized accessor]
slot-definition-name (slot-definition slot-definition) => result
(setf (slot-definition-name (slot-definition slot-definition)) new-value)

[Generic accessor]
slot-definition-readers slot-definition => result
(setf (slot-definition-readers slot-definition) new-value)

[Specialized accessor]
slot-definition-readers (slot-definition slot-definition) => result
(setf (slot-definition-readers (slot-definition slot-definition)) new-value)

[Generic accessor]
slot-definition-type slot-definition => result
(setf (slot-definition-type slot-definition) new-value)

[Specialized accessor]
slot-definition-type (slot-definition slot-definition) => result
(setf (slot-definition-type (slot-definition slot-definition)) new-value)

[Generic accessor]
slot-definition-writers slot-definition => result
(setf (slot-definition-writers slot-definition) new-value)

[Specialized accessor]
slot-definition-writers (slot-definition slot-definition) => result
(setf (slot-definition-writers (slot-definition slot-definition)) new-value)

[Generic function]
slot-makunbound-using-class class object slotd => result

[Method]
slot-makunbound-using-class (class std-class) (object standard-object) (slotd standard-effective-slot-definition) => result

[Method]
slot-makunbound-using-class (class condition-class) object slotd => result

[Method]
slot-makunbound-using-class (class structure-class) (object structure-object) (slotd structure-effective-slot-definition) => result

[Generic accessor]
slot-value-using-class class object slotd => result
(setf (slot-value-using-class class object slotd) new-value)

[Specialized accessor]
slot-value-using-class (class std-class) (object standard-object) (slotd standard-effective-slot-definition) => result
(setf (slot-value-using-class (class std-class) (object standard-object) (slotd standard-effective-slot-definition)) new-value)

[Specialized accessor]
slot-value-using-class (class condition-class) (object condition) (slotd condition-effective-slot-definition) => result
(setf (slot-value-using-class (class condition-class) (object condition) (slotd condition-effective-slot-definition)) new-value)

[Specialized accessor]
slot-value-using-class (class structure-class) (object structure-object) (slotd structure-effective-slot-definition) => result
(setf (slot-value-using-class (class structure-class) (object structure-object) (slotd structure-effective-slot-definition)) new-value)

[Standard class]
specializer

[Generic function]
specializer-direct-generic-functions specializer => result

[Method]
specializer-direct-generic-functions (specializer class) => result

[Method]
specializer-direct-generic-functions (specializer specializer-with-object) => result

[Generic function]
specializer-direct-methods specializer => result

[Method]
specializer-direct-methods (specializer class) => result

[Method]
specializer-direct-methods (specializer specializer-with-object) => result

[Standard class]
standard-accessor-method

[Standard class]
standard-class

[Standard class]
standard-direct-slot-definition

[Standard class]
standard-effective-slot-definition

[Standard class]
standard-generic-function

[Accessor]
standard-instance-access instance location => result
(setf (standard-instance-access instance location) new-value)

[Standard class]
standard-method

[Standard class]
standard-object

[Standard class]
standard-reader-method

[Standard class]
standard-slot-definition

[Standard class]
standard-writer-method

[Function]
subclassp class superclass => result

[Function]
subtypep type1 type2 &optional environment => result

[Function]
typep object type &optional environment => result