a-to-c

[Gregor J. Kiczales <gregor@parc.xerox.com>]

\begingfcom{add-dependent}

\label Syntax:

\Defgen {add-dependent} {metaobject dependent}

\label Arguments:

The {\it metaobject} argument is a class or generic function metaobject.

The {\it dependent} argument is an object.

\label Values:

The value returned by this generic function is unspecified.

\label Purpose:

The generic function {\bf add-dependent} updates the set of dependents
of {\it metaobject} to include {\it dependent}.  If {\it dependent} is
already in the set of dependents it is not added again (no error is
signalled).

The generic function {\bf map-dependents} can be called to access the
set of dependents of a class or generic function.  The generic function
{\bf remove-dependent} can be called to remove an object from the set of
dependents of a class or generic function.  The effect of calling {\bf
add-dependent} or {\bf remove-depedent} while a call to {\bf
map-dependents} is in progress is unspecified.

When {\it metaobject} is reinitialized by {\bf reinitialize-instance}
each of its dependents is updated.  This is done by calling {\bf
map-dependents} so that {\bf update-dependent} can be called on each
dependent.

The situations in which {\bf add-dependent} is called are not specified.

\label Methods:

\Defmeth {add-dependent} {({\it class\/} standard-class) {\it
dependent\/}}

No behavior is specified for this method beyond that specified for the
generic function.

This method cannot be overridden unless the following methods are
overridden as well:

\begingroup\advance\leftskip 2pc
\method{remove-dependent}{standard-class t}\hfil\break
\method{map-dependents}{standard-class t}
\par\endgroup

\newpage

\Defmeth {add-dependent} {({\it generic-function\/}
standard-generic-function) {\it dependent\/}}

No behavior is specified for this method beyond that specified for the
generic function.

This method cannot be overridden unless the following methods are
overridden as well:

\begingroup\advance\leftskip 2pc
\method{remove-dependent}{standard-generic-function t}\hfil\break
\method{map-dependents}{standard-generic-function t}
\par\endgroup

\label Remarks:

Portable code must not use metaobjects themselves as dependents.
Instead, portable programs which need to record a metaobject as a
dependent, should encapsulate that metaobject in some other kind of
object, and record that object as the dependent.

This requirement prevents two portable programs, or a portable program
and the implementation from inadvertently removing dependents recorded
by one another.

\label Example:

This example shows a general facility for encapsulating metaobjects
before recording them as dependents.  The facility defines a basic kind
of encapsulating object: an updater.  Specializations of the basic class
can be defined with appropriate special updating behavior.  In this way,
information about the updating required is associated with each updater
rather than with the metaobject being updated.

\screen!
;;;
;;; Updaters are used encapsulate any metaobject which needs updating
;;; when a given class or generic function is modified. RECORD-UPDATER
;;; is called to both create an updater and add it to the dependents of
;;; the class or generic functions.  Methods on the generic function
;;; UPDATE-DEPENDENT, specialized to the specific class of updater do
;;; the appropriate update work.
;;;
(defclass updater ()
     ((dependee  :initarg :dependee  :reader dependee)
      (dependent :initarg :dependent :reader dependent)))

(defun record-updater (class dependee dependent &rest initargs)
  (let ((updater (apply #'make-instance class :dependee dependee
                                              :dependent dependent
                                              initargs)))
    (add-dependent dependee updater)
    updater))

;;;
;;; A FLUSH-CACHE-UPDATER simply flushes the cache of the dependent
;;; when it is updated.
;;;
(defclass flush-cache-updater (updater) ())

(defmethod update-dependent ((updater flush-cache-updater) &rest args)
  (declare (ignore args))
  (flush-cache (dependent updater)))
\endscreen!

\label See Also:

``The Dependent Maintenance Protocol''

{\bf remove-dependent}

{\bf map-dependents}

{\bf update-dependent}

\endcom

\begingfcom{add-direct-method}

\label Syntax:

\Defgen {add-direct-method} {specializer method}

\label Arguments:

The {\it specializer\/} argument is a method specializer.  The results
are
undefined if it is not one of the specializers of {\it method\/}.

The {\it method} argument is a method metaobject.

\label Values:

The value returned by this generic function is unspecified.

\label Purpose:

The generic function {\bf add-direct-method} is called to maintain a set
of backpointers from a specializer to the set of methods specialized to
it.  When called, if {\it method} is already in the set, it is not added
again (no error is signalled).

This set can be accessed as a list by calling the generic function {\bf
specializer-direct-methods}.  Methods can be removed from the set by
calling {\bf remove-direct-method}.  The effect of calling {\bf
add-direct-method} or {\bf remove-direct-method} on previously returned
values of {\bf specializer-direct-methods} is unspecified.

The generic function {\bf add-direct-method} is called by {\bf
add-method} whenever a method is added to a generic function.  It is
called once for each of the specializers of the method.

\label Methods:

\Defmeth {add-direct-method} {\vtop{\hbox{({\it specializer} class)}
                                    \hbox{({\it method} method)}}}

No behavior is specified for this method beyond that which is specified
for
the generic function.

This method cannot be overridden unless the following methods are
overridden as well:

\begingroup\advance\leftskip 2pc
\method{remove-direct-method}{class method}\hfil\break
\method{specializer-direct-methods}{class}
\par\endgroup

\newpage

\Defmeth {add-direct-method} {\vtop{\hbox{({\it specializer} cons)}
                                    \hbox{({\it method} method)}}}

This method implements the behavior of the generic function for {\bf
eql} specializers.  When {\it specializer} is a list of the form
{\bf(eql {\it object})}, {\it method} is added to a list of methods
associated with {\it object}.  This list is returned by
\method{specializer-direct-methods}{cons}.

If {\it specializer} is not a list of the form {\bf(eql {\it object})},
the behavior of this method is unspecified.

This method cannot be overridden unless the following methods are
overridden as well:

\begingroup\advance\leftskip 2pc
\method{remove-direct-method}{cons method}\hfil\break
\method{specializer-direct-methods}{cons}
\par\endgroup

\label See Also:

{\bf remove-direct-method}

{\bf specializer-direct-methods}

\endcom

\begingfcom{add-direct-subclass}

\label Syntax:

\Defgen {add-direct-subclass} {superclass subclass}

\label Arguments:

The {\it superclass} argument is a class metaobject.

The {\it subclass} argument is a class metaobject.

\label Values:

The value returned by this generic function is unspecified.

\label Purpose:

The generic function {\bf add-direct-subclass} is called to maintain a
set of backpointers from a class to its direct subclasses.  This generic
function adds {\it subclass} to the set of direct subclasses of {\it
superclass}.  If {\it subclass} is already in the set it is not added
again (no error is signalled).

The generic function {\bf class-direct-subclasses} returns the set as a
list.  A class can be removed from the set by calling {\bf
remove-direct-subclass}.  The effect of calling {\bf
add-direct-subclass} or {\bf remove-direct-subclass} on previously
returned values of {\bf class-direct-subclasses} is unspecified.

When a class is initialized, this generic function is called once for
each direct superclass of the class.

When a class is reinitialized, this generic function is called once for
each added direct superclass of the class.  The generic function {\bf
remove-direct-subclass} is called once for each deleted direct
superclass of the class.

\label Methods:

\Defmeth {add-direct-subclass} {\vtop{\hbox{({\it superclass\/} class)} 
                                      \hbox{({\it subclass\/} class)}}}

No behavior is specified for this method beyond that which is specified
for
the generic function.

This method cannot be overridden unless the following methods are
overridden as well:

\begingroup\advance\leftskip 2pc
\method{remove-direct-subclass}{class class}\hfil\break
\method{class-direct-subclasses}{class}
\par\endgroup

\newpage

\label See Also:

{\bf remove-direct-subclass}

{\bf class-direct-subclasses}

\endcom

\begingfcom{add-method}

\label Syntax:

\Defgen {add-method} {generic-function method}

\label Arguments:

The {\it generic-function\/} argument is a generic function metaobject.

The {\it method\/} argument is a method metaobject.  The lambda-list of
the method function must be congruent with the lambda-list of the
generic function, or an error is signaled.

\label Values:

The modified generic function is returned.  The result of {\bf
add-method} 
is {\bf eq} to the {\it generic-function\/} argument.

\label Purpose:

The generic function {\bf add-method} adds a method to the set of
methods associated with a generic function.  After adding the method to
this set, {\bf compute-discriminating-function} is called and its result
is installed by calling {\bf set-funcallable-instance-function}.  The
{\it generic-function} argument is destructively modified and returned
as the the result.

If the method metaobject is already associated with a generic function
an error is signalled.

The set of methods associated with the generic function can be accessed
as a list by calling {\bf generic-function-methods}.  A method can be
removed from the set by calling {\bf remove-method}.  The effect of
calling {\bf add-method} or {\bf remove-method} on previous results
returned by {\bf generic-function-methods} is unspecified.

The generic function {\bf add-method} can be called by the user or the
implementation.  It is called whenever a method must be added to a
generic function.

\label Methods:

\Defmeth {add-method} {\vtop{\hbox{({\it generic-function\/}
standard-generic-function)}
                             \hbox{({\it method\/} method)}}}

If the given method agrees with an existing method of the generic
function on parameter specializers and qualifiers, the existing method
is replaced.  See the section of Chapter 1 called ``Agreement on
Parameter Specializers and Qualifiers'' for a definition of agreement in
this context.

This method cannot be overridden unless the following methods are
overridden as well:

\begingroup\advance\leftskip 2pc
\method{remove-method}{standard-generic-function method}\hfil\break
\method{generic-function-methods}{standard-generic-function}
\par\endgroup

\label See Also:

Chapter 1 section --- ``Agreement on Parameter Specializers and
Qualifiers''

{\bf remove-method}

{\bf generic-function-methods}

{\bf compute-discriminating-function}

\endcom

\begingfcom{allocate-instance}

\label Syntax:

\Defgen {allocate-instance} {class {\tt \&rest} {\it initargs\/}}

\label Arguments:

The {\it class\/} argument is a class metaobject.

The {\it initargs\/} argument consists of alternating initialization
argument
names and values.

\label Values:

The value returned by {\bf allocate-instance} is a newly allocated
instance.

\label Purpose:

The generic function {\bf allocate-instance} is called to create a new,
uninitialized instance of a class.  The interpretation of the concept of
an ``unitialized instance'' depends on the method.

Before allocating the new instance, {\bf class-finalized-p} is called to
see if {\it class} has been finalized.  If it has not been finalized,
{\bf finalize-inheritance} is called before the new instance is
allocated.

\label Methods:

\Defmeth {allocate-instance} 
         {({\it class\/} standard-class) {\rest} {\it initargs}}

The instance returned by this method has slots which are unbound.

\vskip 1.6pc

\Defmeth {allocate-instance}
         {({\it class\/} structure-class) {\rest} {\it initargs}}

The instance returned by this method has slots with undefined values.

\vskip 1.6pc

\Defmeth {allocate-instance} 
         {({\it class\/} built-in-class) {\rest} {\it initargs}}

This method signals an error.

\endcom

\begingfcom{compute-applicable-methods}

\label Syntax:

\Defgen {compute-applicable-methods} {generic-function arguments}

\label Arguments:

The {\it generic-function} argument is a generic function metaobject.

The {\it arguments} argument is a list of objects.

\label Values:

This generic function returns a possibly empty list of method
metaobjects.

\label Purpose:

The generic function {\bf compute-applicable-methods} determines the
method applicability of a generic function given a list of required
arguments for the generic function.  The returned list of method
metaobjects is sorted by precedence order with the most specific method
is first.  If no methods are applicable to the supplied arguments the
empty list is returned.

When a generic function is invoked, the discriminating function must
determine the ordered list of methods applicable to the arguments.
Depending on the generic function and the arguments, this is done in one
of three ways: using a memoized value; calling {\bf
compute-applicable-methods-using-classes}; or calling {\bf
compute-applicable-methods}.  Refer to the description of {\bf
compute-discriminating-function} for the details of this process.

For any given generic function and set of arguments, if {\bf
compute-applicable-methods-using-classes} returns a second value of
true, the first value must be equal to the value returned by a
corresponding call to {\bf compute-applicable-methods}.  The results are
undefined if this is not the case.

The {\it arguments} argument must have at least as many elements as the
generic function accepts required arguments.  If fewer arguments are
supplied, an error is signalled.

\label Methods:

\Defmeth {compute-applicable-methods} 
         {\vtop{\hbox{({\it generic-function}
standard-generic-function)}
                \hbox{{\it arguments\/}}}}

This method signals an error if any method of the generic function has a
specializer which is not either a class metaobject or a list of the form
{\bf(eql {\it object})}.

Otherwise, this method computes the sorted list of applicable methods
according to the rules described in the section of Chapter 1 called
``Method Selection and Combination''.

This method can be overridden.  Because of the consistency requirements
between this generic function and {\bf
compute-applicable-methods-using-classes}, doing so may require also
overidding
\method{compute-applicable-methods-using-classes}{standard-generic-function
t}.

\label See Also:

``Method Lookup Protocol''

{\bf compute-applicable-methods-using-classes}

{\bf compute-discriminating-function}

\endcom

\begingfcom{compute-applicable-methods-using-classes}

\label Syntax:

\Defgen {compute-applicable-methods-using-classes} {generic-function
classes}

\label Arguments:

The {\it generic-function} argument is a generic function metaobject.

The {\it classes} argument is a list of class metaobjects.

\label Values:

This generic function returns two values.  The first is a possibly empty
list of method metaobjects.  The second is either true or false.

\label Purpose:

The generic function {\bf compute-applicable-methods-using-classes} is
called to attempt to determine the method applicability given only the
classes of the required arguments to the generic function.

If it is possible to completely determine the ordered list of applicable
methods based only on the supplied classes, this generic function
returns that list as its first value and true as its second value.  The
returned list of method metaobjects is sorted by precedence order, the
most specific method is first.  If no methods are applicable to the
specified arguments the empty list is returned.

If it is not possible to completely determine the ordered list of
applicable methods based only on the supplied classes, this generic
function returns an unspecified first value and false as its second
value.

When a generic function is invoked, the discriminating function must
determine the ordered list of methods applicable to the arguments.
Depending on the generic function and the arguments, this is done in one
of three ways: using a memoized value; calling {\bf
compute-applicable-methods-using-classes}; or calling {\bf
compute-applicable-methods}.  Refer to the description of {\bf
compute-discriminating-function} for the details of this process.

For any given generic function and set of arguments, if {\bf
compute-applicable-methods-using-classes} returns a second value of
true, the first value must be equal to the value returned by {\bf
compute-applicable-methods}.  The results are undefined if this is not
the case.

\newpage

\label Methods:

\Defmeth {compute-applicable-methods-using-classes} 
         {\vtop{\hbox{({\it generic-function}
standard-generic-function)}
                \hbox{({\it classes\/} t)}}}

If any method of the generic function has a specializer which is neither
a class metaobject nor a list of the form {\bf(eql {\it object})}, this
method returns an unspecified first value and false as its second value.

In cases where the generic function has no methods with {\bf eql}
specializers, or has no methods with {\bf eql} specializers which could
be applicable to arguments of the supplied classes, this method returns
the ordered list of applicable methods as its first value and true as
its second value.

Otherwise this method returns an unspecified first value and false as
its second value.

This method can be overridden. Because of the consistency requirements
between this generic function and {\bf compute-applicable-methods},
doing so may require also overidding
\method{compute-applicable-methods}{standard-generic-function t}.

\label Remarks:

This generic function exists to support extensions which modify the
rules of method applicability but which base the new, modified rules
only on the classes of the arguments to the generic function.  Such
extensions can be implemented by two methods, one on this generic
function and another on {\bf compute-applicable-methods}.

An extension which bases method applicability on properties of the
arguments to the generic function other than their class, as is the
case with {\bf eql} specializers, can be implemented in one of two ways.

The first involves two methods definitions.  One method on this generic
function which returns a second value of false as appropriate together
with a method on {\bf compute-applicable-methods} which computes the
ordered set of applicable methods using the desired method applicability
rules.

The second involves definining a method on {\bf
compute-discriminating-function}.  The discriminating function returned
by this method implements the desired method applicability rules
directly without making any calls to {\bf compute-applicable-methods} or
{\bf compute-applicable-methods-using-classes}.

\label See Also:

``Method Lookup Protocol''

{\bf compute-applicable-methods}

{\bf compute-discriminating-function}

\endcom

\begingfcom{compute-class-precedence-list}

\label Syntax:

\Defgen {compute-class-precedence-list} {class}

\label Arguments:

The {\it class} argument is a class metaobject.

\label Values:

The value returned by this generic function is a list of class
metaobjects.

\label Purpose:

The generic-function {\bf compute-class-precedence-list} is called to
determine the class precedence list of a class.  

The result is a proper list which contains each of {\it class} and its
superclasses once and only once.  The first element of the list is {\it
class}
and the last element is the class named {\bf t}.

All methods on this generic function must compute the class precedence
list as a function of the ordered direct superclasses of the
superclasses of {\it class}.  The results are undefined if the rules
used to compute the class precedence list depend on any other factors.

This generic function can be called by the user or the implementation.
When a class is finalized, {\bf finalize-inheritance} calls this generic
function and associates the returned value with the class metaobject.
The value can then be accessed by calling {\bf class-precedence-list}.

\label Methods:

\Defmeth {compute-class-precedence-list} {({\it class} class)}

This method computes the class precedence list according to the rules
described in the section of Chapter 1 called ``Determining the Class
Precedence List''.

If the specified class or any of its superclasses is a forward
referenced class an error is signalled.

This method can be overridden.

\label See Also:

Chapter 1 section --- ``Determining the Class Precedence List''

{\bf finalize-inheritance}

{\bf class-precedence-list}

\endcom

\begingfcom{compute-discriminating-function}

\label Syntax:

\Defgen {compute-discriminating-function} {generic-function}

\label Arguments:

The {\it generic-function} argument is a generic function metaobject.

\label Values:

The value returned by this generic function is a function.

\label Purpose:

The generic function {\bf compute-discriminating-function} is called to
determine the discriminating function for a generic function.  When a
generic function is called, the discriminating function is called to
implement the behavior of calling the generic function:  determining the
ordered set of applicable methods, determining the effective method, and
running the effective method.

To determine the ordered set of applicable methods, the discriminating
function first calls {\bf compute-applicable-methods-using-classes}.  If
{\bf compute-applicable-methods-using-classes} returns a second value of
false, the discriminating function then calls {\bf
compute-applicable-methods}.

When {\bf compute-applicable-methods-using-classes} returns a second
value of true, the discriminating function is permitted to memoize the
first returned value as follows.  If the generic function is called
again with required arguments which are instances of the same classes;
and the generic function has not been reinitialized; and no method has
been added to the generic function; and no method has been removed from
the generic function; and for all the specializers of all the generic
function's methods which are classes the class precedence list has not
changed; for any such memoized value, no class precedence list of the
required argument classes has changed; then the discriminating function
may reuse the list of applicable methods without calling {\bf
compute-applicable-methods-using-classes} again.

Determination of the the effective method is done by calling {\bf
compute-effective-method}.

When the effective method is run, each method's function is called using
the result of calling {\bf method-function-applier}.

The result of {\bf compute-discriminating-function} is intended to be
used as the discriminating function for {\it generic-function} and is
intended to replace all previous discriminating functions for {\it
generic-function}.  The result of {\bf compute-discriminating-function}
cannot be called directly with {\bf apply} or {\bf funcall}.  Instead,
once it has been installed with {\bf set-funcallable-instance-function},
the generic function itself can be called.  Once {\bf
compute-discriminating-function} is called, the result must be installed
before {\it generic-function} is called again.  Moreover the installed
discriminating function must not subsequently be replaced by a previous
result of {\bf compute-discriminating-function}.

This generic function is called, and the result is installed by {\bf
add-method}, {\bf remove-method}, {\bf initialize-instance} and {\bf
reinitialize-instance}.

\label Methods:

\Defmeth {compute-discriminating-function} {({\it generic-function}
standard-generic-function)}

This method returns a discriminating function as described above.

This method can be shadowed.  The shadowing method is permitted to call
{\bf call-next-method} and return a result which itself calls the result
of this method.

This method can be overridden.

\label See Also:

``The Method Lookup Protocol''

{\bf compute-applicable-methods}

{\bf compute-applicable-methods-using-classes}

{\bf compute-effective-method}

{\bf make-method-lambda}

{\bf method-function-applier}

\endcom

\begingfcom{compute-effective-method}

\label Syntax:

\Defgen {compute-effective-method} {generic-function method-combination
methods}

\label Arguments:

The {\it generic-function} argument is a generic function metaobject.

The {\it method-combination} argument is a method combination
metaobject.

The {\it methods} argument is a list of method metaobjects.

\label Values:

This generic function returns two values.  The first is an effective
method.  The second is a list of effective method options.

\label Purpose:

The generic function {\bf compute-effective-method} is called to
determine the effective method from a sorted list of method metaobjects.

The first value returned by this generic function is the effective
method.  The second is a list of effective method options, these have
the same syntax and interpretation as the options argument to the long
form of define method combination.

This generic function can be called by the user or the implementation.
It is called whenever a sorted list of applicable methods must be
converted to an effective method.  It is called by the result of \method
{compute-discriminating-function} {standard-generic-function}.

Because neither method nor method combination metaobjects can be
reinitialized, the results of this generic function may be memoized.

\label Methods:

\Defmeth {compute-effective-method}
         {\vtop{\hbox{({\it generic-function}
standard-generic-function)}
                \hbox{({\it method-combination}
standard-method-combination)}
                \hbox{{\it methods}}}}

This method computes the effective method according to the rules of the
method combination type implemented by {\it method-combination}.

This method can be overridden.

\vskip 1.6pc

\Defmeth {compute-effective-method}
         {\vtop{\hbox{({\it generic-function}
standard-generic-function)}
                \hbox{({\it method-combination}
standard-simple-method-combination)}
                \hbox{{\it methods}}}}

This method computes the effective method according to the rules of the
method combination type implemented by {\it method-combination}.

This method can be overridden.

\label See Also:

``Method Lookup Protocol''

Chapter 1 section --- ``Applying Method Combination to the Sorted List
of Applicable Methods''

{\bf define-method-combination}

{\bf compute-discriminating-function}

\endcom

\begingfcom{compute-effective-slot-definition}

\label Syntax:

\Defgen {compute-effective-slot-definition} 
        {class name direct-slot-definitions} 

\label Arguments:

The {\it class} argument is a class metaobject.

The {\it name} argument is a slot name.

The {\it direct-slot-definitions} argument is a list of direct slot
definition metaobjects.  

\label Values:

The value returned by this generic function is an effective slot
definition
metaobject.

\label Purpose:

This generic function determines the effective slot definition for each
slot in a class.  It is called by {\bf compute-slots} once for each slot
accessible in instances of {\it class}.

This generic function uses the supplied list of direct slot definition
metaobjects to compute the inheritance of slot properties for a single
slot.  The returned effective slot definition represents the result of
computing the inheritance.  

The class of the effective slot definition metaobject is determined by
calling {\bf effective-slot-definition-class}.  The effective slot
definition is then created by calling {\bf make-instance}.

It is not specified what initialization arguments are passed in this
call to {\bf make-instance}.  All implementation initialization of the
effective slot definition will be done by implementation methods on {\bf
shared-initialize}.  (With the exception of the slot location which is
done by {\bf compute-slots}.)

\label Methods:

\Defmeth {compute-effective-slot-definition} 
         {\vtop{\hbox{({\it class} standard-class)}
                \hbox{{\it name}}
                \hbox{{\it superclass-slot-definitions}}}}

This method implements the inheritance and defaulting of slot options
following the rules described in the ``Inheritance of Slots and
Options'' section of Chapter 1.

This method signals an error if the value returned by the {\bf
effective-slot-definition-class} the class {\bf
standard-effective-slot-definition} or one of its subclasses.

This method cannot be overridden; it can be shadowed, but the value
returned by the shadowing method must be the value returned by this
method.

\vskip 1.6pc

\Defmeth {compute-effective-slot-definition}
         {\vtop{\hbox{({\it class} structure-class)}
                \hbox{{\it name}}
                \hbox{{\it superclass-slot-definitions}}}}

This method implements the inheritance and defaulting of slot options
following the rules described for {\bf defstruct}.

This method signals an error if the value returned by the {\bf
effective-slot-definition-class} the class {\bf
structure-effective-slot-definition} or one of its subclasses.

This method cannot be overridden; it can be shadowed, but the value
returned by the shadowing method must be the value returned by this
method.

\label See Also:

{\bf compute-slots}

{\bf effective-slot-definition-class}

\endcom

\begingfcom{compute-slots}

\label Syntax:

\Defgen {compute-slots} {class}

\label Arguments:

The {\it class} argument is a class metaobject.

\label Purpose:

This generic function computes a set of effective slot definition
metaobjects for the class {\it class}.  The result is a list of
effective slot definition metaobjects: one for each slot that will be
accessible in instances of {\it class}.

This generic function proceeds in 4 steps:

The first step collects the full set of direct slot definitions from the
superclasses of {\it class}.

The direct slot definitions are then collected into individual lists,
one list for each slot name associated with any of the direct slot
definitions.  The slot names are compared with {\bf eql}.  Each such
list is then sorted into class precedence list order.  Direct slot
definitions coming from classes earlier in the class precedence list of
{\it class} appear before those coming from classes later in the class
precedence list.

For each slot name, the generic function {\bf
compute-effective-slot-definition} is called to compute an effective
slot definition.  The result of {\bf compute-slots} is a list of these
effective slot definitions, in unspecified order.

In the final step, the location for each effective slot definition is
set.  For more information on the slot definition locations, see the
section ``Accessing Slots Directly''.

\label Methods:

\Defmeth {compute-slots} {({\it class} standard-class)}

This method implements the specified behavior of the generic function.

This method can be overriden.

\vskip 1.6pc

\Defmeth {compute-slots} {({\it class} structure-class)}

This method implements the specified behavior of the generic function.

\label See Also:

{\bf compute-effective-slot-definition}

{\bf effective-slot-definition-class}

\endcom