- 29.5.1. Inheritance Structure of generic function metaobject Classes
- 29.5.2. Introspection: Readers for generic function metaobjects
- 29.5.2.1. Generic Function
CLOS:GENERIC-FUNCTION-NAME - 29.5.2.2. Generic Function
CLOS:GENERIC-FUNCTION-METHODS - 29.5.2.3. Generic Function
CLOS:GENERIC-FUNCTION-LAMBDA-LIST - 29.5.2.4. Generic Function
CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER - 29.5.2.5. Generic Function
CLOS:GENERIC-FUNCTION-DECLARATIONS - 29.5.2.6. Generic Function
CLOS:GENERIC-FUNCTION-METHOD-CLASS - 29.5.2.7. Generic Function
CLOS:GENERIC-FUNCTION-METHOD-COMBINATION - 29.5.2.8. Methods
- 29.5.2.1. Generic Function
- 29.5.3. Initialization of Generic Functions
- 29.5.4. Customization
- 29.5.4.1. Generic Function
(SETF CLOS:GENERIC-FUNCTION-NAME) - 29.5.4.2. Generic Function
ENSURE-GENERIC-FUNCTION - 29.5.4.3. Generic Function
CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS - 29.5.4.4. Generic Function
ADD-METHOD - 29.5.4.5. Generic Function
REMOVE-METHOD - 29.5.4.6. Generic Function
CLOS:COMPUTE-APPLICABLE-METHODS - 29.5.4.7. Generic Function
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES - 29.5.4.8. Generic Function
CLOS:COMPUTE-EFFECTIVE-METHOD - 29.5.4.9. Function
CLOS:COMPUTE-EFFECTIVE-METHOD-AS-FUNCTION - 29.5.4.10. Generic Function
CLOS:MAKE-METHOD-LAMBDA - 29.5.4.11. Generic Function
CLOS:COMPUTE-DISCRIMINATING-FUNCTION
- 29.5.4.1. Generic Function
29.5.1. Inheritance Structure of generic function metaobject Classes
29.5.2. Introspection: Readers for generic function metaobjects
- 29.5.2.1. Generic Function
CLOS:GENERIC-FUNCTION-NAME - 29.5.2.2. Generic Function
CLOS:GENERIC-FUNCTION-METHODS - 29.5.2.3. Generic Function
CLOS:GENERIC-FUNCTION-LAMBDA-LIST - 29.5.2.4. Generic Function
CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER - 29.5.2.5. Generic Function
CLOS:GENERIC-FUNCTION-DECLARATIONS - 29.5.2.6. Generic Function
CLOS:GENERIC-FUNCTION-METHOD-CLASS - 29.5.2.7. Generic Function
CLOS:GENERIC-FUNCTION-METHOD-COMBINATION - 29.5.2.8. Methods
The reader generic functions which simply return information associated with generic function metaobjects are presented together here in the format described in Section 29.3.3, “Introspection: Readers for class metaobjects”.
Each of the reader generic functions for generic function metaobjects has the same
syntax, accepting one required argument called generic-function, which must be a
generic function metaobject; otherwise, an ERROR is SIGNALed. An ERROR is also SIGNALed if the
generic function metaobject has not been initialized.
These generic functions can be called by the user or the implementation.
For any of these generic functions which returns a list, such lists will not be mutated by the implementation. The results are undefined if a portable program allows such a list to be mutated.
29.5.2.1. Generic Function CLOS:GENERIC-FUNCTION-NAME
(CLOS:GENERIC-FUNCTION-NAME generic-function)
CLOS:GENERIC-FUNCTION-NAME generic-function)Returns the name of the generic function, or NIL if the generic
function has no name. This is the defaulted value of the :NAME
initialization argument that was associated with the generic function metaobject during
initialization or reinitialization.
(See also (SETF CLOS:GENERIC-FUNCTION-NAME).)
29.5.2.2. Generic Function CLOS:GENERIC-FUNCTION-METHODS
(CLOS:GENERIC-FUNCTION-METHODS generic-function)
CLOS:GENERIC-FUNCTION-METHODS generic-function)Returns the set of methods currently connected to the generic
function. This is a set of method metaobjects. This value is maintained by the
generic functions ADD-METHOD and REMOVE-METHOD.
29.5.2.3. Generic Function CLOS:GENERIC-FUNCTION-LAMBDA-LIST
(CLOS:GENERIC-FUNCTION-LAMBDA-LIST generic-function)
CLOS:GENERIC-FUNCTION-LAMBDA-LIST generic-function)Returns the lambda list of the generic function. This is the
defaulted value of the :LAMBDA-LIST initialization argument that was
associated with the generic function metaobject during initialization or reinitialization.
An ERROR is SIGNALed if the lambda list has yet to be supplied.
29.5.2.4. Generic Function CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
(CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER generic-function)
CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER generic-function)Returns the argument precedence order of the generic function.
This value is a list of symbols, a permutation of the required
parameters in the lambda list of the generic function. This is the
defaulted value of the :ARGUMENT-PRECEDENCE-ORDER initialization
argument that was associated with the generic function metaobject during initialization or
reinitialization.
Implementation dependent: only in CLISP
An ERROR is SIGNALed if the lambda list has not yet been
supplied.
29.5.2.5. Generic Function CLOS:GENERIC-FUNCTION-DECLARATIONS
(CLOS:GENERIC-FUNCTION-DECLARATIONS generic-function)
CLOS:GENERIC-FUNCTION-DECLARATIONS generic-function)Returns a possibly empty list of the “declarations”
of the generic function. The elements of this list are
declaration specifiers. This list is the defaulted value of the
:DECLARATIONS initialization argument that was associated with the
generic function metaobject during initialization or reinitialization.
29.5.2.6. Generic Function CLOS:GENERIC-FUNCTION-METHOD-CLASS
(CLOS:GENERIC-FUNCTION-METHOD-CLASS generic-function)
CLOS:GENERIC-FUNCTION-METHOD-CLASS generic-function)Returns the default method class of the generic function. This
class must be a subclass of the class METHOD. This is the defaulted
value of the :METHOD-CLASS initialization argument that was
associated with the generic function metaobject during initialization or reinitialization.
29.5.2.7. Generic Function CLOS:GENERIC-FUNCTION-METHOD-COMBINATION
(CLOS:GENERIC-FUNCTION-METHOD-COMBINATION generic-function)
CLOS:GENERIC-FUNCTION-METHOD-COMBINATION generic-function)Returns the method combination of the generic function. This is a
method combination metaobject. This is the defaulted value of the :METHOD-COMBINATION
initialization argument that was associated with the generic function metaobject during
initialization or reinitialization.
The specified methods for the generic function metaobject reader generic functions
(CLOS:GENERIC-FUNCTION-NAME(generic-functionSTANDARD-GENERIC-FUNCTION))(CLOS:GENERIC-FUNCTION-LAMBDA-LIST(generic-functionSTANDARD-GENERIC-FUNCTION))(CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER(generic-functionSTANDARD-GENERIC-FUNCTION))(CLOS:GENERIC-FUNCTION-DECLARATIONS(generic-functionSTANDARD-GENERIC-FUNCTION))(CLOS:GENERIC-FUNCTION-METHOD-CLASS(generic-functionSTANDARD-GENERIC-FUNCTION))(CLOS:GENERIC-FUNCTION-METHOD-COMBINATION(generic-functionSTANDARD-GENERIC-FUNCTION))- No behavior is specified for these methods beyond that which is specified for their respective generic functions.
(CLOS:GENERIC-FUNCTION-METHODS(generic-functionSTANDARD-GENERIC-FUNCTION))No behavior is specified for this method beyond that which is specified for the generic function.
The value returned by this method is maintained by
ADD-METHOD(STANDARD-GENERIC-FUNCTIONSTANDARD-METHOD)REMOVE-METHOD(STANDARD-GENERIC-FUNCTIONSTANDARD-METHOD)
29.5.3.1. Macro DEFGENERIC
The evaluation or execution of a DEFGENERIC form results in a
call to the ENSURE-GENERIC-FUNCTION function. The arguments received by ENSURE-GENERIC-FUNCTION
are derived from the DEFGENERIC form in a defined way. As with
DEFCLASS and DEFMETHOD, the exact macro-expansion of the
DEFGENERIC form is not defined, only the relationship between the
arguments to the macro and the arguments received by ENSURE-GENERIC-FUNCTION.
- The
function-nameargument toDEFGENERICbecomes the first argument toENSURE-GENERIC-FUNCTION. This is the only positional argument accepted byENSURE-GENERIC-FUNCTION; all other arguments are keyword arguments. - The
lambda-listargument toDEFGENERICbecomes the value of the:LAMBDA-LISTkeyword argument toENSURE-GENERIC-FUNCTION. For each of the options
:ARGUMENT-PRECEDENCE-ORDER,:DOCUMENTATION,:GENERIC-FUNCTION-CLASSand:METHOD-CLASS, the value of the option becomes the value of the keyword argument with the same name. If the option does not appear in the macro form, the keyword argument does not appear in the resulting call toENSURE-GENERIC-FUNCTION.Implementation dependent: only in CLISP
If the option does not appear in the macro form, the keyword argument appears in the resulting call to
ENSURE-GENERIC-FUNCTION, with a default value: thelambda-listfor:ARGUMENT-PRECEDENCE-ORDER,NILfor:DOCUMENTATION, the classSTANDARD-GENERIC-FUNCTIONfor:GENERIC-FUNCTION-CLASS, the classSTANDARD-METHODfor:METHOD-CLASS. This is needed to make the generic function reflect theDEFGENERICform.For the option
:DECLARE, the list of “declarations” becomes the value of the:DECLARATIONSkeyword argument. If the:DECLAREoption does not appear in the macro form, the:DECLARATIONSkeyword argument does not appear in the call toENSURE-GENERIC-FUNCTION.Implementation dependent: only in CLISP
If the
:DECLAREoption does not appear in the macro form, the:DECLARATIONSkeyword argument appears in the resulting call toENSURE-GENERIC-FUNCTION, with a default value ofNIL. This is needed to make the generic function reflect theDEFGENERICform.The handling of the
:METHOD-COMBINATIONoption is not specified.Implementation dependent: only in CLISP
If the
:METHOD-COMBINATIONoption does not appear in the macro form, the:METHOD-COMBINATIONkeyword argument still appears in the resulting call toENSURE-GENERIC-FUNCTION, but in a position where it can be overridden by user-defined initargs and default initargs.Implementation dependent: only in CLISP
The
:DECLAREkeyword is recognized as equivalent to the:DECLARATIONSkeyword, for compatibility withENSURE-GENERIC-FUNCTIONin [ANSI CL standard]. If both:DECLAREand:DECLARATIONSkeyword arguments are specified, anERRORisSIGNALed.Any other generic function options become the value of keyword arguments with the same name. The value of the keyword argument is the tail of the generic function option. An
ERRORisSIGNALed if any generic function option appears more than once in theDEFGENERICform.The default initargs of the
generic-function-classare added at the end of the list of arguments to pass toENSURE-GENERIC-FUNCTION. This is needed to make the generic function reflect theDEFGENERICform.Implementation dependent: only in CLISP
User-defined options. Any other options become the value of keyword arguments with the same name. The value of the keyword argument is the tail of the option. An
ERRORisSIGNALed if any option appears more than once in theDEFGENERICform.
The result of the call to ENSURE-GENERIC-FUNCTION is returned as the result of
evaluating or executing the DEFGENERIC form.
Associated with each generic function is its discriminating function. Each time the generic function is called, the discriminating function is called to provide the behavior of the generic function. The discriminating function receives the full set of arguments received by the generic function. It must lookup and execute the appropriate methods, and return the appropriate values.
The discriminating function is computed by the highest layer of
the generic function invocation protocol, CLOS:COMPUTE-DISCRIMINATING-FUNCTION.
Whenever a generic function metaobject is initialized, reinitialized, or a method is added or
removed, the discriminating function is recomputed.
The new discriminating function is then stored with
CLOS:SET-FUNCALLABLE-INSTANCE-FUNCTION.
Discriminating functions call CLOS:COMPUTE-APPLICABLE-METHODS
and CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES to compute the methods
applicable to the generic functions arguments.
Applicable methods are combined by CLOS:COMPUTE-EFFECTIVE-METHOD to
produce an effective method
.
Provisions are made to allow memoization of the method applicability and
effective methods computations. (See the description of
CLOS:COMPUTE-DISCRIMINATING-FUNCTION for details.)
The body of method definitions are processed by CLOS:MAKE-METHOD-LAMBDA.
The result of this generic function is a lambda expression
which is processed by either COMPILE or COMPILE-FILE to produce a
method function.
The arguments received by the method function are controlled by the
CALL-METHOD forms appearing in the effective methods.
By default, method functions accept two arguments: a list of arguments
to the generic function, and a list of next methods.
The list of next methods corresponds to the next methods argument to
CALL-METHOD.
If CALL-METHOD appears with additional arguments, these will be passed
to the method functions as well; in these cases, CLOS:MAKE-METHOD-LAMBDA
must have created the method lambdas to expect additional arguments.
Implementation dependent: only in CLISP
See The generic function CLOS:MAKE-METHOD-LAMBDA is not implemented.
29.5.3.3. Initialization of generic function metaobjects
A generic function metaobject can be created by calling MAKE-INSTANCE. The
initialization arguments establish the definition of the generic
function. A generic function metaobject can be redefined by calling REINITIALIZE-INSTANCE.
Some classes of generic function metaobject do not support redefinition; in these cases,
REINITIALIZE-INSTANCE SIGNALs an ERROR.
Initialization of a generic function metaobject must be done by calling MAKE-INSTANCE
and allowing it to call INITIALIZE-INSTANCE. Reinitialization of a
generic function metaobject must be done by calling REINITIALIZE-INSTANCE.
Portable programs must not
- ... call
INITIALIZE-INSTANCEdirectly to initialize a generic function metaobject; - ... call
SHARED-INITIALIZEdirectly to initialize or reinitialize a generic function metaobject; - ... call
CHANGE-CLASSto change the class of any generic function metaobject or to turn a non-generic-function object into a generic function metaobject.
Since metaobject classes may not be redefined,
no behavior is specified for the result of calls to
UPDATE-INSTANCE-FOR-REDEFINED-CLASS on generic function metaobjects.
Since the class of a generic function metaobject may not be changed,
no behavior is specified for the results of calls to
UPDATE-INSTANCE-FOR-DIFFERENT-CLASS on generic function metaobjects.
During initialization or reinitialization, each initialization argument is checked for errors and then associated with the generic function metaobject. The value can then be accessed by calling the appropriate accessor as shown in Table 29.4, “Initialization arguments and accessors for generic function metaobjects”.
This section begins with a description of the error checking and processing of each initialization argument. This is followed by a table showing the generic functions that can be used to access the stored initialization arguments. The section ends with a set of restrictions on portable methods affecting generic function metaobject initialization and reinitialization.
In these descriptions, the phrase “this argument defaults to
value” means that when that initialization argument is not
supplied, initialization or reinitialization is performed as if
value had been supplied. For some initialization arguments this
could be done by the use of default initialization arguments, but
whether it is done this way is not specified. Implementations are free
to define default initialization arguments for specified generic function metaobject classes.
Portable programs are free to define default initialization arguments
for portable subclasses of the class GENERIC-FUNCTION.
Unless there is a specific note to the contrary, then during reinitialization, if an initialization argument is not supplied, the previously stored value is left unchanged.
The
:ARGUMENT-PRECEDENCE-ORDERargument is a list of symbols.An
ERRORisSIGNALed if this argument appears but the:LAMBDA-LISTargument does not appear. AnERRORisSIGNALed if this value is not a proper list or if this value is not a permutation of the symbols from the required arguments part of the:LAMBDA-LISTinitialization argument.When the generic function is being initialized or reinitialized, and this argument is not supplied, but the
:LAMBDA-LISTargument is supplied, this value defaults to the symbols from the required arguments part of the:LAMBDA-LISTargument, in the order they appear in that argument. If neither argument is supplied, neither are initialized (see the description of:LAMBDA-LIST.)The
:DECLARATIONSargument is a list of declaration specifiers.An
ERRORisSIGNALed if this value is not a proper list or if each of its elements is not a legal declaration specifier.When the generic function is being initialized, and this argument is not supplied, it defaults to the empty list.
- The
:DOCUMENTATIONargument is aSTRINGorNIL. AnERRORisSIGNALed if it is not. This argument default toNILduring initialization. The
:LAMBDA-LISTargument is a lambda list.An
ERRORisSIGNALed if this value is not a proper generic function lambda list.When the generic function is being initialized, and this argument is not supplied, the generic function's lambda list is not initialized. The lambda list will be initialized later, either when the first method is added to the generic function, or a later reinitialization of the generic function.
- The
:METHOD-COMBINATIONargument is a method combination metaobject. The
:METHOD-CLASSargument is a class metaobject.An
ERRORisSIGNALed if this value is not a subclass of the classMETHOD.When the generic function is being initialized, and this argument is not supplied, it defaults to the class
STANDARD-METHOD.The
:NAMEargument is an object.If the generic function is being initialized, this argument defaults to
NIL.
After the processing and defaulting of initialization arguments described above, the value of each initialization argument is associated with the generic function metaobject. These values can then be accessed by calling the corresponding generic function. The correspondences are as follows:
Table 29.4. Initialization arguments and accessors for generic function metaobjects
| Initialization Argument | Generic Function |
|---|---|
:ARGUMENT-PRECEDENCE-ORDER | CLOS:GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER |
:DECLARATIONS | CLOS:GENERIC-FUNCTION-DECLARATIONS |
:DOCUMENTATION | DOCUMENTATION |
:LAMBDA-LIST | CLOS:GENERIC-FUNCTION-LAMBDA-LIST |
:METHOD-COMBINATION | CLOS:GENERIC-FUNCTION-METHOD-COMBINATION |
:METHOD-CLASS | CLOS:GENERIC-FUNCTION-METHOD-CLASS |
:NAME | CLOS:GENERIC-FUNCTION-NAME |
It is not specified which methods provide the initialization and reinitialization behavior described above. Instead, the information needed to allow portable programs to specialize this behavior is presented as a set of restrictions on the methods a portable program can define. The model is that portable initialization methods have access to the generic function metaobject when either all or none of the specified initialization has taken effect.
These restrictions govern the methods that a portable program can
define on the generic functions INITIALIZE-INSTANCE,
REINITIALIZE-INSTANCE, and SHARED-INITIALIZE. These restrictions
apply only to methods on these generic functions for which the first
specializer is a subclass of the class GENERIC-FUNCTION. Other
portable methods on these generic functions are not affected by these
restrictions.
- Portable programs must not define methods on
SHARED-INITIALIZE. For
INITIALIZE-INSTANCEandREINITIALIZE-INSTANCE:- Portable programs must not define primary methods.
- Portable programs may define around-methods, but these must be extending, not overriding methods.
- Portable before-methods must assume that when they are run, none of the initialization behavior described above has been completed.
- Portable after-methods must assume that when they are run, all of the initialization behavior described above has been completed.
The results are undefined if any of these restrictions are violated.
- 29.5.4.1. Generic Function
(SETF CLOS:GENERIC-FUNCTION-NAME) - 29.5.4.2. Generic Function
ENSURE-GENERIC-FUNCTION - 29.5.4.3. Generic Function
CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS - 29.5.4.4. Generic Function
ADD-METHOD - 29.5.4.5. Generic Function
REMOVE-METHOD - 29.5.4.6. Generic Function
CLOS:COMPUTE-APPLICABLE-METHODS - 29.5.4.7. Generic Function
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES - 29.5.4.8. Generic Function
CLOS:COMPUTE-EFFECTIVE-METHOD - 29.5.4.9. Function
CLOS:COMPUTE-EFFECTIVE-METHOD-AS-FUNCTION - 29.5.4.10. Generic Function
CLOS:MAKE-METHOD-LAMBDA - 29.5.4.11. Generic Function
CLOS:COMPUTE-DISCRIMINATING-FUNCTION
29.5.4.1. Generic Function (SETF CLOS:GENERIC-FUNCTION-NAME)
- Syntax
((SETF CLOS:GENERIC-FUNCTION-NAME)new-namegeneric-function)- Arguments
generic-function- a generic function metaobject.
new-name- a function name or
NIL.
- Value
- The
new-nameargument. - Purpose
This function changes the name of
generic-functiontonew-name. This value is usually a function name orNIL, if the generic function is to have no name.This function works by calling
REINITIALIZE-INSTANCEwithgeneric-functionas its first argument, the symbol:NAMEas its second argument andnew-nameas its third argument.
29.5.4.2. Generic Function ENSURE-GENERIC-FUNCTION
- Syntax
(ENSURE-GENERIC-FUNCTIONfunction-name&KEY&ALLOW-OTHER-KEYS)- Arguments
function-name- a function name
- keyword arguments
- Some of the keyword arguments accepted by this
function are actually processed by
CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS, others are processed during initialization of the generic function metaobject (as described in Section 29.5.3.3, “Initialization of generic function metaobjects”).
- Value
- A generic function metaobject.
- Purpose
This function is called to define a globally named generic function or to specify or modify options and declarations that pertain to a globally named generic function as a whole. It can be called by the user or the implementation.
It is the functional equivalent of
DEFGENERIC, and is called by the expansion of theDEFGENERICandDEFMETHODmacros.The behavior of this function is actually implemented by the generic function
CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS. WhenENSURE-GENERIC-FUNCTIONis called, it immediately callsCLOS:ENSURE-GENERIC-FUNCTION-USING-CLASSand returns that result as its own.The first argument to
CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASSis computed as follows:- If
function-namenames a non-generic function, a macro, or a special form, anERRORisSIGNALed. - If
function-namenames a generic function, that generic function metaobject is used. - Otherwise,
NILis used.
The second argument is
function-name. The remaining arguments are the complete set of keyword arguments received byENSURE-GENERIC-FUNCTION.- If
29.5.4.3. Generic Function CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS
- Syntax
(CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASSgeneric-functionfunction-name&KEY:ARGUMENT-PRECEDENCE-ORDER:DECLARATIONS:DOCUMENTATION:GENERIC-FUNCTION-CLASS:LAMBDA-LIST:METHOD-CLASS:METHOD-COMBINATION:NAME&ALLOW-OTHER-KEYS)- Arguments
generic-function- a generic function metaobject or
NIL. function-name- a function name
:GENERIC-FUNCTION-CLASS- a class metaobject or a class name.
If it is not supplied, it defaults to the class named
STANDARD-GENERIC-FUNCTION. If a class name is supplied, it is interpreted as the class with that name. If a class name is supplied, but there is no such class, anERRORisSIGNALed. - additional keyword arguments
see Section 29.5.3.3, “Initialization of generic function metaobjects”.
Implementation dependent: only in CLISP
The
:DECLAREkeyword is recognized as equivalent to the:DECLARATIONSkeyword, for compatibility withENSURE-GENERIC-FUNCTIONin [ANSI CL standard].
- Value
- A generic function metaobject.
- Purpose
The generic function
CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASSis called to define or modify the definition of a globally named generic function. It is called by theENSURE-GENERIC-FUNCTIONfunction. It can also be called directly.The first step performed by this generic function is to compute the set of initialization arguments which will be used to create or reinitialize the globally named generic function. These initialization arguments are computed from the full set of keyword arguments received by this generic function as follows:
- The
:GENERIC-FUNCTION-CLASSargument is not included in the initialization arguments. - If the
:METHOD-CLASSargument was received by this generic function, it is converted into a class metaobject. This is done by looking up the class name withFIND-CLASS. If there is no such class, anERRORisSIGNALed. - All other keyword arguments are included directly in the initialization arguments.
If the
generic-functionargument isNIL, an instance of the class specified by the:GENERIC-FUNCTION-CLASSargument is created by callingMAKE-INSTANCEwith the previously computed initialization arguments. The function namefunction-nameis set to name the generic function. The newly created generic function metaobject is returned.If the class of the
generic-functionargument is not the same as the class specified by the:GENERIC-FUNCTION-CLASSargument, anERRORisSIGNALed.Implementation dependent: only in CLISP
The description of
ENSURE-GENERIC-FUNCTIONin [ANSI CL standard] specifies that in this case,CHANGE-CLASSis called if the class of thegeneric-functionargument and the class specified by the:GENERIC-FUNCTION-CLASSargument are compatible. Given the description ofENSURE-GENERIC-FUNCTION, this also applies to theCLOS:ENSURE-GENERIC-FUNCTION-USING-CLASSfunction. CLISP's implementation callsCHANGE-CLASSalways, and leaves it to theCHANGE-CLASSfunction to signal an error if needed.Otherwise the generic function
generic-functionis redefined by calling theREINITIALIZE-INSTANCEgeneric function withgeneric-functionand the initialization arguments. Thegeneric-functionargument is then returned.- The
Methods
(CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS(generic-functionGENERIC-FUNCTION)function-name&KEY:GENERIC-FUNCTION-CLASS&ALLOW-OTHER-KEYS)This method implements the behavior of the generic function in the case where
function-namenames an existing generic function.This method can be overridden.
(CLOS:ENSURE-GENERIC-FUNCTION-USING-CLASS(generic-functionNULL)function-name&KEY:GENERIC-FUNCTION-CLASS&ALLOW-OTHER-KEYS)- This method implements the behavior of the generic
function in the case where
function-namenames no function, generic function, macro or special form.
29.5.4.4. Generic Function ADD-METHOD
- Syntax
(ADD-METHODgeneric-functionmethod)- Arguments
generic-function- a generic function metaobject.
method- a method metaobject.
- Value
- The
generic-functionargument. - Purpose
This generic function associates an unattached method with a generic function.
An
ERRORisSIGNALed if the lambda list of the method is not congruent with the lambda list of the generic function.An
ERRORisSIGNALed if the method is already associated with some other generic function.If the given method agrees with an existing method of the generic function on parameter specializers and qualifiers, the existing method is removed by calling
REMOVE-METHODbefore the new method is added. See the [ANSI CL standard] section 7.6.3 “Agreement on Parameter Specializers and Qualifiers” for a definition of agreement in this context.Associating the method with the generic function then proceeds in four steps:
- add
methodto the set returned byCLOS:GENERIC-FUNCTION-METHODSand arrange forCLOS:METHOD-GENERIC-FUNCTIONto returngeneric-function; - call
CLOS:ADD-DIRECT-METHODfor each of the method's specializers; - call
CLOS:COMPUTE-DISCRIMINATING-FUNCTIONand install its result withCLOS:SET-FUNCALLABLE-INSTANCE-FUNCTION; and - update the dependents of the generic function.
The generic function
ADD-METHODcan be called by the user or the implementation.- add
Methods
(ADD-METHOD(generic-functionSTANDARD-GENERIC-FUNCTION) (methodSTANDARD-METHOD))- No behavior is specified for this method beyond that which is specified for the generic function.
(ADD-METHOD(generic-functionSTANDARD-GENERIC-FUNCTION) (methodMETHOD))- This method is specified by [ANSI CL standard].
29.5.4.5. Generic Function REMOVE-METHOD
- Syntax
(REMOVE-METHODgeneric-functionmethod)- Arguments
generic-function- a generic function metaobject.
method- a method metaobject.
- Value
- The
generic-functionargument. - Purpose
This generic function breaks the association between a generic function and one of its methods.
No
ERRORisSIGNALed if the method is not among the methods of the generic function.Breaking the association between the method and the generic function proceeds in four steps:
- remove
methodfrom the set returned byCLOS:GENERIC-FUNCTION-METHODSand arrange forCLOS:METHOD-GENERIC-FUNCTIONto returnNIL; - call
CLOS:REMOVE-DIRECT-METHODfor each of the method's specializers; - call
CLOS:COMPUTE-DISCRIMINATING-FUNCTIONand install its result withCLOS:SET-FUNCALLABLE-INSTANCE-FUNCTION; and - update the dependents of the generic function.
The generic function
REMOVE-METHODcan be called by the user or the implementation.- remove
Methods
(REMOVE-METHOD(generic-functionSTANDARD-GENERIC-FUNCTION) (methodSTANDARD-METHOD))- No behavior is specified for this method beyond that which is specified for the generic function.
(REMOVE-METHOD(generic-functionSTANDARD-GENERIC-FUNCTION) (methodMETHOD))- This method is specified by [ANSI CL standard].
29.5.4.6. Generic Function CLOS:COMPUTE-APPLICABLE-METHODS
- Syntax
(CLOS:COMPUTE-APPLICABLE-METHODSgeneric-functionarguments)- Arguments
generic-function- a generic function metaobject.
arguments- a list of objects.
- Value
- A possibly empty list of method metaobjects.
- Purpose
This generic function determines the method applicability of a generic function given a list of required arguments. The returned list of method metaobjects is sorted by precedence order with the most specific method appearing 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
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES; or callingCLOS:COMPUTE-APPLICABLE-METHODS. (Refer to the description ofCLOS:COMPUTE-DISCRIMINATING-FUNCTIONfor the details of this process.)The
argumentsargument is permitted to contain more elements than the generic function accepts required arguments; in these cases the extra arguments will be ignored. AnERRORisSIGNALed ifargumentscontains fewer elements than the generic function accepts required arguments.The list returned by this function will not be mutated by the implementation. The results are undefined if a portable program mutates the list returned by this function.
Methods
(CLOS:COMPUTE-APPLICABLE-METHODS(generic-functionSTANDARD-GENERIC-FUNCTION)arguments)This method
SIGNALs anERRORif any method of the generic function has a specializer which is neither a class metaobject nor anEQLspecializer metaobject.Otherwise, this method computes the sorted list of applicable methods according to the rules described in the [ANSI CL standard] section 7.6.6 “Method Selection and Combination”
This method can be overridden. Because of the consistency requirements between this generic function and
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES, doing so may require also overridingCLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES(STANDARD-GENERIC-FUNCTIONT)
Remarks.
See also the [ANSI CL standard] function COMPUTE-APPLICABLE-METHODS.
29.5.4.7. Generic Function CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES
- Syntax
(CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSESgeneric-functionclasses)- Arguments
generic-function- a generic function metaobject.
classes- a list of class metaobjects.
- Values
- A possibly empty list of method metaobjects.
BOOLEAN
- Purpose
This generic function is called to attempt to determine the method applicability of a generic function given only the classes of the required arguments.
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 primary value and true as its second value. The returned list of method metaobjects is sorted by precedence order, the most specific method coming first. If no methods are applicable to arguments with the specified classes, the empty list and true are 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 primary 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
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES; or callingCLOS:COMPUTE-APPLICABLE-METHODS. (Refer to the description ofCLOS:COMPUTE-DISCRIMINATING-FUNCTIONfor the details of this process.)The following consistency relationship between
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSESandCLOS:COMPUTE-APPLICABLE-METHODSmust be maintained: for any given generic function and set of arguments, ifCLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSESreturns a second value of true, the primary value must be equal to the value that would be returned by a corresponding call toCLOS:COMPUTE-APPLICABLE-METHODS. The results are undefined if a portable method on either of these generic functions causes this consistency to be violated.The list returned by this function will not be mutated by the implementation. The results are undefined if a portable program mutates the list returned by this function.
Methods
(CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES(generic-functionSTANDARD-GENERIC-FUNCTION)classes)If any method of the generic function has a specializer which is neither a class metaobject nor an
EQLspecializer metaobject, this methodSIGNALs anERROR.In cases where the generic function has no methods with
EQLspecializers, or has no methods withEQLspecializers that 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 primary value and false as its second value.
This method can be overridden. Because of the consistency requirements between this generic function and
CLOS:COMPUTE-APPLICABLE-METHODS, doing so may require also overridingCLOS:COMPUTE-APPLICABLE-METHODS(STANDARD-GENERIC-FUNCTIONT)
This generic function exists to allow user extensions which alter method lookup rules, but which base the new rules only on the classes of the required arguments, to take advantage of the class-based method lookup memoization found in many implementations. (There is of course no requirement for an implementation to provide this optimization.)
Such an extension can be implemented by two methods, one on this
generic function and one on CLOS:COMPUTE-APPLICABLE-METHODS. Whenever
the user extension is in effect, the first method will return a second
value of true. This should allow the implementation to absorb these
cases into its own memoization scheme.
To get appropriate performance, other kinds of extensions may
require methods on CLOS:COMPUTE-DISCRIMINATING-FUNCTION which implement
their own memoization scheme.
29.5.4.8. Generic Function CLOS:COMPUTE-EFFECTIVE-METHOD
- Syntax
(CLOS:COMPUTE-EFFECTIVE-METHODgeneric-functionmethod-combinationmethods)- Arguments
generic-function- a generic function metaobject.
method-combination- a method combination metaobject.
methods- a list of method metaobjects.
- Values
- An effective method
- A list of effective method options
- Purpose
This generic function is called to determine the effective method from a sorted list of method metaobjects.
An effective method is a form that describes how the applicable methods are to be combined. Inside of effective method forms are
CALL-METHODforms which indicate that a particular method is to be called. The arguments to theCALL-METHODform indicate exactly how the method function of the method should be called. (SeeCLOS:MAKE-METHOD-LAMBDAfor more details about method functions.)An effective method option has the same interpretation and syntax as either the
:ARGUMENTSor the:GENERIC-FUNCTIONoption in the long form ofDEFINE-METHOD-COMBINATION.More information about the form and interpretation of effective methods and effective method options can be found under the description of the
DEFINE-METHOD-COMBINATIONmacro in the CLOS specification.This generic function can be called by the user or the implementation. It is called by discriminating functions whenever a sorted list of applicable methods must be converted to an effective method.
Methods
(CLOS:COMPUTE-EFFECTIVE-METHOD(generic-functionSTANDARD-GENERIC-FUNCTION)method-combinationmethods)This method computes the effective method according to the rules of the method combination type implemented by
method-combination.This method can be overridden.
Implementation dependent: only in CLISP
The second return value may contain only one
:ARGUMENTS option and only one :GENERIC-FUNCTION option. When overriding a
CLOS:COMPUTE-EFFECTIVE-METHOD method, before adding an :ARGUMENTS or
:GENERIC-FUNCTION option, you therefore need to check whether it this option is
already present.
29.5.4.9. Function CLOS:COMPUTE-EFFECTIVE-METHOD-AS-FUNCTION
Implementation dependent: only in CLISP
- Syntax
(CLOS:COMPUTE-EFFECTIVE-METHOD-AS-FUNCTIONgeneric-functionmethodsarguments)- Arguments
generic-function- a generic function metaobject.
methods- a list of method metaobjects.
arguments- a list of arguments.
- Value
- The effective method as a function, accepting any set of arguments for which all of the given methods are applicable.
- Purpose
This function is called to determine the effective method from a sorted list of method metaobjects, and convert it to a function. The
argumentsare a set of arguments to which the methods are applicable, and are used solely for error message purposes.This function calls
CLOS:COMPUTE-EFFECTIVE-METHODusing thegeneric-function's method combination, wraps local macro definitions forCALL-METHODandMAKE-METHODaround it, handles the:ARGUMENTSand:GENERIC-FUNCTIONoptions, and compiles the resulting form to a function.
29.5.4.10. Generic Function CLOS:MAKE-METHOD-LAMBDA
- Syntax
(CLOS:MAKE-METHOD-LAMBDAgeneric-functionmethodlambda-expressionenvironment)- Arguments
generic-function- a generic function metaobject.
method- a (possibly uninitialized) method metaobject.
lambda-expression- a lambda expression.
environment- the same as the
&ENVIRONMENTargument to macro expansion functions.
- Values
- A lambda expression
- A list of initialization arguments and values
- Purpose
This generic function is called to produce a lambda expression which can itself be used to produce a method function for a method and generic function with the specified classes. The generic function and method the method function will be used with are not required to be the given ones. Moreover, the method metaobject may be uninitialized.
Either the function
COMPILE, the special formFUNCTIONor the functionCOERCEmust be used to convert the lambda expression a method function. The method function itself can be applied to arguments withAPPLYorFUNCALL.When a method is actually called by an effective method, its first argument will be a list of the arguments to the generic function. Its remaining arguments will be all but the first argument passed to
CALL-METHOD. By default, all method functions must accept two arguments: the list of arguments to the generic function and the list of next methods.For a given generic function and method class, the applicable methods on
CLOS:MAKE-METHOD-LAMBDAandCLOS:COMPUTE-EFFECTIVE-METHODmust be consistent in the following way: each use ofCALL-METHODreturned by the method onCLOS:COMPUTE-EFFECTIVE-METHODmust have the same number of arguments, and the method lambda returned by the method onCLOS:MAKE-METHOD-LAMBDAmust accept a corresponding number of arguments.Note that the system-supplied implementation of
CALL-NEXT-METHODis not required to handle extra arguments to the method function. Users who define additional arguments to the method function must either redefine or foregoCALL-NEXT-METHOD. (See the example below.)When the method metaobject is created with
MAKE-INSTANCE, the method function must be the value of the:FUNCTIONinitialization argument. The additional initialization arguments, returned as the second value of this generic function, must also be passed in this call toMAKE-INSTANCE.
Methods
(CLOS:MAKE-METHOD-LAMBDA(generic-functionSTANDARD-GENERIC-FUNCTION) (methodSTANDARD-METHOD)lambda-expressionenvironment)This method returns a method lambda which accepts two arguments, the list of arguments to the generic function, and the list of next methods. What initialization arguments may be returned in the second value are unspecified.
This method can be overridden.
This example shows how to define a kind of method which, from
within the body of the method, has access to the actual method metaobject for the
method. This simplified code overrides whatever method combination is
specified for the generic function, implementing a simple method
combination supporting only primary methods, CALL-NEXT-METHOD and
NEXT-METHOD-P. (In addition, its a simplified version of
CALL-NEXT-METHOD which does no error checking.)
Notice that the extra lexical function bindings get wrapped around
the body before CALL-NEXT-METHOD is called. In this way, the user's
definition of CALL-NEXT-METHOD and NEXT-METHOD-P are sure to
override the system's definitions.
(defclass my-generic-function (standard-generic-function)
()
(:default-initargs :method-class (find-class 'my-method)))
(defclass my-method (standard-method) ())
(defmethod make-method-lambda ((gf my-generic-function)
(method my-method)
lambda-expression
environment)
(declare (ignore environment))
`(lambda (args next-methods this-method)
(,(call-next-method gf method
`(lambda ,(cadr lambda-expression)
(flet ((this-method () this-method)
(call-next-method (&REST cnm-args)
(funcall (method-function (car next-methods))
(or cnm-args args)
(cdr next-methods)
(car next-methods)))
(next-method-p ()
(not (null next-methods))))
,@(cddr lambda-expression)))
environment)
args next-methods)))
(defmethod compute-effective-method ((gf my-generic-function)
method-combination
methods)
`(call-method ,(car methods) ,(cdr methods) ,(car methods)))
Implementation dependent: only in CLISP
The generic function CLOS:MAKE-METHOD-LAMBDA is not implemented. Its specification is misdesigned: it mixes compile time and
execution time behaviour. The essential problem is: where could the
generic-function argument come from?
- If a
DEFMETHODform occurs in a source file, isCLOS:MAKE-METHOD-LAMBDAthen called at compile time or at load time? If it was called at compile time, there's no possible value for the first argument, since the class of the generic function to which the method will belong is not known until load time. If it was called at load time, it would mean that the method's source code could only be compiled at load time, not earlier - which defeats the purpose ofCOMPILE-FILE - When a method is removed from a generic function
using
REMOVE-METHODand then added throughADD-METHODto a different generic function, possibly belonging to a different generic function class, wouldCLOS:MAKE-METHOD-LAMBDAthen be called again or not? If no, thenCLOS:MAKE-METHOD-LAMBDA's first argument is useless. If yes, then the source code of every method would have to be present at runtime, and its lexical environment as well.
CALL-METHODalways expect exactly two arguments: the method and a list of next methods.- Method functions always expect exactly two arguments: the list of arguments passed to the generic function, and the list of next methods.
29.5.4.11. Generic Function CLOS:COMPUTE-DISCRIMINATING-FUNCTION
- Syntax
(CLOS:COMPUTE-DISCRIMINATING-FUNCTIONgeneric-function)- Arguments
generic-function- a generic function metaobject.
- Value
- A function.
- Purpose
This generic function is called to determine the discriminating function for a generic function. When a generic function is called, the installed discriminating function is called with the full set of arguments received by the generic function, and must 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
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES. IfCLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSESreturns a second value of false, the discriminating function then callsCLOS:COMPUTE-APPLICABLE-METHODS.When
CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSESreturns a second value of true, the discriminating function is permitted to memoize the primary value as follows. The discriminating function may reuse the list of applicable methods without callingCLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSESagain provided that:- the generic function is being called again with required arguments which are instances of the same classes,
- the generic function has not been reinitialized,
- no method has been added to or removed from the generic function,
- for all the specializers of all the generic function's methods which are classes, their class precedence lists have not changed, and
- for any such memoized value, the class precedence list of the class of each of the required arguments has not changed.
Determination of the effective method is done by calling
CLOS:COMPUTE-EFFECTIVE-METHOD. When the effective method is run, each method's function is called, and receives as arguments:- a list of the arguments to the generic function,
- whatever other arguments are specified in the
CALL-METHODform indicating that the method should be called.
(See
CLOS:MAKE-METHOD-LAMBDAfor more information about how method functions are called.)The generic function
CLOS:COMPUTE-DISCRIMINATING-FUNCTIONis called, and its result installed, byADD-METHOD,REMOVE-METHOD,INITIALIZE-INSTANCEandREINITIALIZE-INSTANCE.
Methods
(CLOS:COMPUTE-DISCRIMINATING-FUNCTION(generic-functionSTANDARD-GENERIC-FUNCTION))No behavior is specified for this method beyond that which is specified for the generic function.
This method can be overridden.
Implementation dependent: only in CLISP
Overriding methods can make use of the function
CLOS:COMPUTE-EFFECTIVE-METHOD-AS-FUNCTION. It is more convenient to call
CLOS:COMPUTE-EFFECTIVE-METHOD-AS-FUNCTION than CLOS:COMPUTE-EFFECTIVE-METHOD
because the in the latter case one needs a lot of “glue
code” for implementing the local macros CALL-METHOD and
MAKE-METHOD, and this glue code is implementation dependent because
it needs
- to retrieve the declarations list stored in the method-combination object and
- to handle implementation dependent options that
are returned as second value from
CLOS:COMPUTE-EFFECTIVE-METHOD.
![[CLISP home]](clisp.png){kind=small}
![[Support CLISP]](http://images.sourceforge.net/images/project-support.jpg){kind=small}