Star Sapphire Common LISP Home
Download Star Saphire
Index

Here is a definitive list of all Star Sapphire CLOS features. The ones preceded by an asterisk are Star Sapphire extensions:

* all-instances

The Common LISP Object System (CLOS) is an object-oriented extension to Common LISP. It is based on generic functions, multiple inheritance, declarative method combination, and a meta-object protocol.

This specification describes the standard Progammer Interface for CLOS.

The first part, Programmer Interface Concepts, contains a description of the concepts of CLOS, and the second part, Functions in the Programmer Interface, contains a description of the functions and macros of CLOS.

The fundamental objects of CLOS are classes, instances, generic functions, and methods.

A class object determines the structure and behavior of a set of other objects, which are called its instances. Every Common LISP object is an instance of a class. The class of an object determines the set of operations that can be performed on the object.

A generic function is a function whose behavior depends on the classes or identities of the arguments supplied to it. A generic function object contains a set of methods, a lambda-list, a method combination type and other information. The methods define the class-specific behavior and operations of the generic functinon; a method is said to specialize a generic function. When invoked, a generic function executes a subset of its methods based on the classes of its arguments.

A generic function can be used in the same ways as an ordinary function in Common LISP; in particular, a generic function can be used as an argument to funcall and apply and can be given a global or a local name.

A method is an object that contains a method function, a sequence of parameter specializers that specify when the given method is applicable, and a sequence of qualifiers that is used by the method combinations facility to distinguish among methods. Each required formal parameter of each method has an associated parameter specializer, and the method will be invoked only on arguments that satisfy its parameter specializers.

The method combination facility controls the selection of methods, the order in which they are run, and the values that are returned by the generic function. CLOS offers a default method combination type and provides a facility for declaring new types of method combination.

The terminology used in this chapter to describe erroneous situations differs from the terminology used elsewhere in this document. The new terminology involves situations; a situation is the evaluation of an expression in some specific context. For example, a situation might be the invocation of a function on arguments that fail to satisfy some specified constraints.

In the specification of CLOS, the behavior of programs in all situations is described, and the options available to the implementor are defined. No implementation is allowed to extend the syntax of CLOS except as explicitly defined in the Object System specification. In particular, no implementation is allowed to extend the syntax of the Object System in such a way that ambiguity between the specified syntax of the Object System and those extensions is possible.

"When situation S occurs, an error is signaled."

This terminology has the following meaning:

If this situation occurs, an error will be signalled in the interpreter and in code compiled under all compiler safety optimization levels.

Valid programs may rely on the fact that an error will be signaled in the interpreter and in code compiled under all compiler safety optimization levels.

Every implementation is required to detect such an error in the interpreter and in code compiled under all compiler safety optimization levels.

"When situation S occurs, an error should be signaled."

This terminology has the following meaning:

If this situation occurs, an error will be signaled in at least the interpreter and in code compiled under the safest compiler safety optimization level.

Valid programs may not rely on the fact that an error will be signalled.

Every implementation is required to detect such an error at least in the interpreter and in code compiled under the safest compiler safety optimization level.

When an error is not signaled, the results are undefined (see below).

"When situation S occurs, the results are undefined."

This terminology has the following meaning:

If this situation occurs, the results are unpredictable. The results may range from harmless to fatal.

Implementations are required to detect this situation and signal an error, but no implementation is required to detect the situation.

No valid program may depend on the effects of this situation, and all valid programs are required to treat the effects of this situation as unpredictable.

"When situation S occurs, the results are unspecified."

This terminology has the following meaning:

The effects of this situation are not specified in the Object System, but the effects are harmless.

Implementations are allowed to specify the effects of this situation.

No portable program can depend on the effects of this situation, and all portable programs are required to treat the situation as unpredictable but harmless.

"CLOS may be extended to cover situation S."

The meaning of this terminology is that an implementation is free to treat situation S in one of three ways:

When situation S occurs, an error is signaled at least in the intepreter and in code compiled under the safest compiler safety optimization level.

When situation S occurs, the results are undefined.

When situation S occurs, the results are defined and specified.

In addition, this terminology has the following meaning:

No portable program can depend on the effects of this situation and all portable programs are required to treat the situation as undefined.

"Implementations are free to extend the syntax S."

This terminology has the following meaning:

Implementations are allowed to define unambiguous extensions to syntax S.

No portable program can depend on this extension, and all portable programs are required to treat the syntax as meaningless.

The CLOS specification may disallow certain extensions while allowing others.

A class is an object that determines the structure and behavior of a set of other objects, which are called its instances.

A class can inherit structure and behavior from other classes. A class whose definition refers to other classes for the purpose of inheriting from them is said to be a subclass of each of those classes. The classes that are designated for purpose of inheritance are said to be superclasses of the inheriting class.

A class can have a name. The function class-name takes a class object and returns its name. The name of an anonymous class is nil. A symbol can name a class. The function find-class takes a symbol and returns the class that the symbol names. A class has a proper name of the name is a symbol and if the name of the class names that class. That is, a class C has the proper name S if S = (class-name C and C = (find-class S). Notice that is possible for (find-class S1)=(find-class S2) and S1 /= S2. If C=(find-class S) we say that C is the class named S.

A class C1 is a direct superclass of a class C2 if C2 explicitly designates C1 as a superclass in its definition. In this case, C2 is a direct superclass of C1. A class Cn is a superclass of a class C1 if there exists a series of classes C2,...,Cn-1 such that Ci+1 is a direct superclass of Ci for 1<=i<n. In this case C1 is a subclass of Cn. A class is considered neither a superclass nor a subclass of itself. That is, if C1 is a superclass of C2, then C1 /= C2. The set of classes consisting of some given class C along with all of its superclasses is called "C and its superclasses."

Each class has a class precedence list, which is a total ordering on the set of the given class and its superclasses. The total ordering is expressed as a list ordered from most specific to least specific. The class precedence list is used in several ways. In general, more specific classes can shadow, or override, features that would otherwise be inherited from less specific classes. The method selection and combination process uses the class precedence list to order methods from most specific to least specific.

When a class is defined, the order in which its direct superclasses are mentioned in the defining form is important. Each class has a local precedence order, which is the list consisting of the class followed by its direct superclasses in the order mentioned in the defining form.

A class precedence list is always consistent with the local precedence order of each class in its list. The classes in each local precedence order appear within the class precedence list in the same order. If the local precedence orders are inconsistent with each other, no class precedence list can be constructed, and an error is signaled. The class precedence list and its computation are discussed in section 28.1.5.

Classes are organized into a directed acyclic graph. There are two distinguished classes, named t and standard-object. The class t has no superclasses. It is a superclass of every class except for itself. The class named standard-object is an instance of the class standard-class and is a superclass of every class that is an instance of standard-class except itself. There is a mapping from the CLOS class space into Common LISP type space. Many of the standard Common LISP types have a corresponding class that have the same name as the type. Some Common LISP types do not have a corresponding class. The integration of the type and class systems is discussed in section 28.1.4.

Classes are represented by objects that are themselves instances of classes. The class of the class of an object is termed the metaclass of that object. When no misinterpretation is possible, the term metaclass will be used to refer to a class that has instances used by the classes that are its instances and the representation of the instances of those classes. CLOS provides a default metaclass, standard-class, that is appropriate for most programs. The meta-object protocol provides mechanisms for defining and using new metaclasses.

Except where otherwise specified, all classes mentioned in this chapter are instances of the class standard-class, all generic functions are instances of the class standard-generic-function, and all methods are instances of the class standard-method.

The macro defclass is used to define a new named class. The definition of a class includes the following:

The slot options and class options of the defclass form provide mechanisms for the following:

The generic function make-instance creates and returns a new instance of a class. The Object System provides several mechanisms for specifying how a new instance is to be initialized. For example, it is possible to specify the initial values for slots in newly created instances either by giving arguments to make-instance or by providing default initial values.

Further initialization activities can be performed by methods written for generic functions that are part of the initialization protocol. The complete initialization protocol is specified in Section 28.1.9.

An object that has standard-class as its metaclass has zero or more named slots. The slots of an object are determined by the class of the object. Each slot can hold one value. The name of a slot is a symbol that is syntactically valid for use as a variable name.

When a slot does not have a value, the slot is said to be unbound. When an unbound slot is read, the generic function slot-unbound is invoked. The system supplied primary method for slot-unbound signals an error.

The default initial value form for a slot is defined by the :initform slot option. When the :initform form is used to supply a value, it is evaluated in the lexical environment in which the defclass form was evaluated. The :initform along with the lexical environment in which the defclass form was evaluated is called a captured :initform (see Section 28.1.9).

A local slot is defined to be a slot that is visible to exactly one instance, namely the one in which the slot is allocated. A share slot is defined to be a slot which is visible to more than one instance of a given class and its subclasses.

A class is said to define a slot with a given name when the defclass from for that class contains a slot specifier with that name. Defining a local slot does not immediately create a slot; it causes a slot to be created each time an instance of the class is created. Defining a shared slot immediately creates a slot.

The :allocation slot option to defclass controls the kind of slot that is defined. If the value of the :allocation slot option is :instance, a local slot is created. If the value of :allocation is :class, a shared slot is created.

A slot is said to be accessible in an instance of a class if the slot is defined by the class of the instance or is inherited from a superclass of that class. At most one slot of a given name can be accessible in an instance. A shared slot defined by a class is accessible in all instances of that class. A detailed explanation of the inheritance of slots is given in Section 28.1.3.2.

Slots can be accessed in two ways: by use of the primitive slot-value and by use of generic functions generated by the defclass form.

The function slot-value can be used with any slot name specified in the defclass form to access a specific slot accessible in an instance of the given class.

The macro defclass provides syntax for generating methods to read and write slots. If a reader is requested, a method is automatically generated for reading the value of the slot, but no method for storing a value into it is generated. If a writer is requested, a method is automatically generated for storing a value into the slot, but no method for reading its value is generated. If an accessor is requested, a method for reading the value of the slot and a method for storing a value into the slot are automatically generated. Reader and writer methods are implemented using slot-value.

When a reader or writer is specified for a slot, the name of the generic function to which the generated method belongs is directly specified. If the name specified for the writer option is the symbol name, the name of the generic function for writing the slot is the symbol name, and the generic function takes two arguments: The new value and the instance, in that order. If the name specified for the accessor option is the symbol name, the name of the generic function for reading the slot is the symbol name and the name of the generic function for writing the slot is the list (setf name).

A generic function created or modified by supplying reader, writer or accessor slot options can be treated exactly as an ordinary generic function.

Note that slot-value can be used to read or write the value of a slot whether or not reader or writer methods exist for that slot. When slot-value is used, no reader or writer methods are invoked.

The macro with-slots can be used to establish a lexical environment in which specified slots are lexically available as if they were variables. The macro with-slots invokes the function slot-value to access the specified slots.

The macro with-accessors can be used to establish a lexical environment in which specified slots are lexically available through their accessors as if they were variables. The macro with-accessors invokes the appropriate accessors to access the specified slots. Any accessors specified by with-accessors must already have been defined before they were used.

A class can inherit methods, slots and some defclass options from its superclasses. The following sections describe the inheritance of methods, the inheritance of slots and slot options, and the inheritance of class options.

A subclass inherits methods in the sense that any method applicable to all instances of a class is also applicable to all instances of any subclass of that class.

The inheritance of methods acts the same way regardless of whether the method was created by using one of the method-defining forms or by using one of the defclass options that causes methods to be generated automatically.

The inheritance of methods is described in detail in Section 28.1.7.

The set of names of all slots accessible in an instance of a class C is the union of the sets of names of slots defined by C and its superclasses. The structure of an instance is the set of names of local slots of that instance.

In the simplest case, only one class among C and its superclasses defines a slot with a given slot name. If a slot is defined by a superclass of C, the slot is said to be inherited. The characteristics of the slot are determined by the slot specifier of the defining class. Consider the definingn class for a slot S. If the value of the ,:allocation slot option is :instance, then S is a local slot and each instance of C has its own slot named S that stores its own value. If the value of the :allocation slot option is :class, then S is a shared slot, the class that defined S stores the value, and all instances of C can access that single slot. If the :allocation slot option is omitted, :instance is used.

In general, more that one class among C and its superclasses can define a slot with a given name. In such cases, only one slot with the given name is accessible in an instance of C, and the characteristics of that slot are a combination of the several slot specifiers, computed as follows:

A consequence of the allocation rule is that a shared slot can be shadowed. For example, if a class C1 defines a slot named S whose value for the :allocation slot option is :class, that slot is accessible in instances of C1 and all of its subclasses. However, if C2 is a subclass of C1 and also defines a slot named S, C1's slot is not shared by instances of C2 and its subclasses. When a class C1 defines a shared slot, any subclass C2 of C1 will share this single slot unless the defclass form for C2 specifies a slot of the same name or there is a superclass of C2 that preceeds C1 in the class precedence list of C2 that defines a slot of the same name.

A consequence of the type rule is that the value of a slot satisfies the type constraint of each slot specifier that contributes to that slot. Because the result of attempting to store in a slot a value that does not satisfy the type constraint for the slot that is undefined, the value in a slot might fail to satisfy its type constraint.

The :reader, :writer, and :accessor slot options create methods rather than inherit the characteristics of a slot. Reader and writer methods are inherited in the sense defined in Section 28.1.3.1.

Methods that access slots use only the name of the slot and the type of the slot's value. Suppose that a superclass provides an method that expects to access a shared slot of a given name, and a subcalss defines a local slot with the same name. If the method provided by the superclass is used on an instance of the subclass, the method accesses the local slot.

The :default-initargs class option is inherited. The set of defaulted initialization arguments for a class is the union of the sets of initialization arguments specified in the :default-initargs class options of the class and its superclasses. When more than one default initial value form is supplied for a given initialization argument, the default initial value form that is used is the one supplied by the class that is most specific according to the class precedence list.

If a given :default-initargs class option specifies an initialization argument of the same name more than once, an error is signaled.

Instances of the class C1 have a local slot named S1, whose default initial value is 5.4 and whose value should always be a number. The class C1 also has a shared slot named S2.

There is a local slot named S1 in instances of C2. The default initial value of S1 is 5. The value of S1 will be of type (and integer number). There are also local slots named S2 and S3 in instances of C2. The class C2 has a method C2-S3 for reading the value of slot S3; there is also a method for (setf C2-S3) that writes the vale of S3.

The Common LISP Object System maps the space of classes into Common LISP type space. Every class that has a proper name has a corresponding type with the same name.

The proper name of every class is a valid type specifier. In addition, every class object is a valid type specifier. Thus the expression (typep object class) evaluates to true if the class of object is class itself or a subclass of class. The evaluation of the expression (subtyepp class1 class2) returns the values t and t if class1 is a subclass of class2 or if they are the same class; otherwise it returns the values nil and t. If I is an instance of some class C named S and C is an instance of standard-class, the evaluation of the expression (type-of I) will return S if S is the proper name of C; if S is not the proper name of C; the expression (type-of I) will return C.

Because the names of classes and class objects are type specifiers, they may be used in the special form the and in type declarations.

Many but not all of the predefined Common LISP type specifiers have a corresponding class with the same proper name as the type. These type specifiers are listed in the following table. For example the type array has a corresponding class named array. No type specifier that is a list, such as (vector double-float 100), has a corresponding class. The form deftype does not create any classes.

The following table contains all class precedence lists for standard types currently defined in Star Sapphire CLOS. The draft ANSI CLOS specification specifies a superset of these which will be implemented in a future version of Star Sapphire.

Each class that corresponds to a predefined Common LISP type specifier can be implemented in one of three ways at the discretion of each implementation. It can be a standard class (of the kind defined by defclass); a structure class (defined by defstruct), or a built-in class (implemented in a special non-extensible way). Star Sapphire implements these using built-in classes.

A built-in class is one whose instances have restricted capabilities or special representations. Attempting to use defclass to define subclasses of a built-in class signals an error. Calling make-instance to create an instance of a built-in class signals an error. Calling slot-value on an instance of a built-in class signals an error. Redefining a built-in class or using change-class to change the class of an instance to or from a built-in class signals an error. However, built-in classes can be used as parameter specializers in methods.

It is possible to determine whether a class is a built-in class by checking the metaclass. A standard class is an instance of standard-class, a built-in class is an instance of built-in-class and a structure class is an instance of structure-class.

Each structure class created by defstruct without using the :type option has a corresponding class. This class is an instance of structure class. The :include option of defstruct creates a direct subclass of the class that corresponds to the included structure.

The purpose of specifying that many of the standard Common LISP type specifiers have a corresponding class is to enable users to write methods that discriminate on these types. Method selection requires that a class precedence list can be determined for each class.

The hierarchical relationships among the Common LISP type specifiers are mirrored by relationships among the classes corresponding to those types. The existing type hierarchy is used for determining the class precedence list for each class that corresponds to a predefined Common LISP type. In some cases, the first edition of Steele did not specify a local precedence order for two supertypes of a given type specifier. For example, null is a subtype of both symbol and list, but the first edition did not specify whether symbol is more specific or less specific than list. The CLOS specificaion defines those relationships for all classes.

The table above lists the set of classes required by the Object System that correpond to predefined Common LISP type specifiers. The superclasses of each such class are presented in order from most specific to most general, thereby defining the class precedence list for the class. The local precedence order for each class that corresponds to a Common LISP type specifier can be derived from this table.

Individual implementations may be extended to define other type specifiers to have a corresponding class. Individual implementations can be extended to add other subclass relationships and to add other elements to the class precedence lists in the above table as long as they do not violate the type relationships and disjointness requirements specified in section 2.15. A standard class defined with no direct superclasses is guaranteed to be disjoint from all of the classes in the table, except for the class named t.

The defclass form for a class provides a total ordering on that class and its direct superclass. This ordering is called the local precedence order. It is an ordered list of the class and its direct superclasses. The class precedence list for a class C is a total ordering on C and its superclasses that is consistent with the local precedence orders for C and its superclasses.

A class preceeds its direct superclasses, and a direct superclass precedes all other direct superclasses specified to its right in the superclasses list of the defclass form. For every class C, define

Rc = {(C,C1,),(C1,C2),...,(Cn-1,Cn)}

where C1,...,Cn are the direct superclasses of C in the order in which they are mentioned in the defclass form. These ordered pairs generate the total ordering on the class C and its direct superclasses.

Let Sc be the set of C and its superclasses. Let R be the union of all classes Rc where c is an element of Sc. The set R may or may not generate a partial ordering, depending on whether the Rc, where c is an element of Sc, are consistent; it is assumed that they are consistent and that R generates a partial ordering. When the Rc are not consistent, it is said that R is inconsistent.

To compute the class precedence list for C, topologically sort the elements of Sc with respect to the partial ordering generated by R. When the topological sort must select a class from a set of two or more classes, none of which are preceded by other classes with respect to R, the class selected is chosen deterministically, as described below. If R is inconsistent, an error is signaled.

Topological sorting proceeds by finding a class C in Sc such that no other class precedes that element according to the elements in R. The class C is placed first in the result. Remove C from Sc, and remove all pairs of the form (C,D), where D is an element of Sc, from R. Repeat the process, adding classes with no predecessors to the end of the result. Stop when no element can be found that has no predecessor.

If Sc is not empty and the process has stopped, the set R is inconsistent. If every class in the finite set of classes is preceded by another, then R contains a loop. That is, there is a chain of classes C1,...,Cn such that Ci precedes Ci+1, 1<=i<n, and Cn precedes C1.

Sometimes there are several classes from Sc with no predecessors. In this case select the one that has a direct subclass rightmost in the class precedence list computed so far. If there is no such candidate class, R does not generate a partial ordering - the Rc, where c is an element of Sc, are inconsistent.

In more precise terms, let {N1,...,Nm}, where m>=2 be the classes from Sc with no predecessors. Let (C1..Cn), where n>=1, be the class precedence list constructed so far. C1 is the most specific class, and Cn is the least specific. Let 1<=j<=n be the largest number such that there exists an i where 1<=i<=m and Ni is a direct superclass of Cj; Ni is placed next.

The effect of this rule for selecting from a set of classes with no predecessors is that classes in a simple superclass chain are adjacent in the class precedence list and that classes in each relatively separated subgraph are adjacent in the class precedence list. For example, let T1 and T2 be subgraphs whose only element in common is the class J. Suppose that no superclass of J appears in either T1 or T2. Let C1 be the bottom of T1; and let C2 be the bottom of T2. Suppose C is a class whose direct superclasses are C1 and C2 in that order; then the class precedence list for C with start with C and will be followed by all classes in T1 except J. All the classes of T2 will be next. The class J and its superclasses will appear last.

The example determines a class precedence list for the class pie.

The following classes are defined:

The class pie is not preceded by anything, so it comes first; the result so far is (pie). Remove pie from S and pairs mentioning pie from R to get

The set R={(apple,cinnamon),(cinnamon,standard-object), (apple,fruit),(fruit,standard-object), (cinnamon,spice),

The class apple is not preceeded by anything, so it is next; the result is (pie apple). Removing apple and the relevant pairs results in

The class cinnamon is next, giving the result so far as (pie apple fruit cinnamon). At this point:

The set S={spice,food,standard-object,t}.

The classes spice, food, standard-object, and t are then added in that order and the final class precedence list for pie is

(pie apple fruit cinnamon spice food standard-object t)

It is possible to write a set of class definitions that cannot be ordered. For example:

The class fruit must precede apple because the local ordering of superclasses must be preserved. The class apple must precede fruit because a class always precedes its own superclasses. When this situation occurs, an error is signaled when the system tries to compute the class precedence list.

The following might appear to be a conflicting set of definitions:

(defclass pie (apple cinnamon)())

The class precedence list for pie is

The class precedence list for pastry is

It is not a problem for apple to precede cinnamon in the ordering of the superclasses of pie but not in the ordering for pastry. However, it is not possible to build a new class that has both pie and pastry as superclasses.

A generic function is a function whose behavior depends on the classes or identities of the arguments supplied to it. The methods define the class-specific behavior and operations of the generic function. The following sections describe generic functions and methods.

28.1.6.1. Introduction to Generic Functions

A generic function object contains a set of methods, a lambda-list, a method combination type, and other information.

Like an ordinary LISP function, a generic function takes arguments, performs a series of operations, and perhaps returns useful values. An ordinary function has a single body of code that is always executed when the function is called. A generic function has a set of bodies of code of which a subset is selected for execution. The selected bodies of code and the manner of their combination are determined by the classes or identities of one or more of the arguments to the generic function and by its method combination type.

Ordinary functions and generic functions are called with identical function-call syntax.

Generic functions are true functions that can be passed as arguments, returned as values, used as the first argument to funcall and apply, and otherwise used in all the ways an ordinary function may be used.

A name can be given to an ordinary function in one of two ways: a global name can be given to a function using the defun construct; a local name can be given using the flet or labels special forms. A generic function can be given a global name using the generic-flet, or with-added-methods special forms. Then name of a generic function, like the name of an ordinary function, can either be a symbol or a two-element list whose first element is setf and whose second element is a symbol. This is true for both local and global names.

[IMPLEMENTATION NOTE: In the current version of Star Sapphire local function definitions are not implemented. References to flet, labels, generic-flet, generic-labels and with-added-methods should be ignored.]

The generic-function macro creates an anonymous generic function with the set of methods specified by the method definitions that appear in the generic-function form.

When a generic form is evaluated, one of three actions is taken;

Some forms specify the options of a generic function, such as the type of method combination it uses or its argument precedence order. They will be refered to as "forms that specify generic function options." These forms are defgeneric, generic-function, generic-flet, generic-labels, and with-added-methods.

Some forms define methods for a generic function. They will be refered to as "method-defining forms". These forms are defgeneric, defmethod, generic-function, generic-flet, generic-labels, with-added-methods, and defclass. Note that all the method-defining forms except defclass and defmethod are also forms that specify generic function options.

A method object contains a method function, a sequence of parameter specializers that specify when the given method is applicable, a lambda-list, and a sequence of qualifiers that are used by the method combination facility to distinguish among methods.

A method object is not a function and cannot be invoked as a function. Various mechanisms in the Object System take a method object and invoke its method function, as is the case when a generic function is invoked. When this occurs it is said that the method is invoked or called.

A method-defining form contains the code that is to be run when the arguments to the generic function cause the method that it defines to be invoked. When a method-defining form is evaluated, a method object is created and one of four actions are taken:

If the lambda-list of a new method is not congruent with the lambda-list of the generic function, an error is signaled. If a method-defining form that cannot specify generic function options creates a new generic function, a lambda-list for that generic function is derived from the lambda-lists of the methods in the method defining forms in such a way to be congruent with them. For a discussion of congruence, see section 28.1.6.4.

Each method has a specialized lambda-list, which determines when that method can be applied. A specialized lambda-list is like an ordinary lambda-list except that a specialize parameter may occur instead of the name of a required parameter. A specialized parameter is a list (variable-name parameter-specializer-name), where parameter-specializer-name is either a name that names a class or a list (eql form). A parameter specializer name denotes a parameter specializer denotes a parameter specializer as follows:

A name that names a class denotes that class.

Parameter specializer names are used in macros intended as the user-level interface (defmethod), while parameter specializers are used in the functional interface.

Only required parameters may be specialized, and there must be a parameter specializer for each required parameter. For notational simplicity, if some required parameter in a specialized lambda-list in a method-defining form is simply a variable name, its parameter specializer defaults to the class named t.

Given a generic function and a set of arguments, an applicable method is a method for that generic function whose parameter specializers are satisfied by their corresponding arguments. The following definition specifies what it means for a method to be applicable and for an argument to satisfy a parameter specializer.

Let <A1,...,An> be the required arguments to a generic function in order. Let <P1,...,Pn> be the parameter specializers corresponding to the required parameters of the method M in order. The method M is applicable when each Ai satisifies Pi. If Pi is a class, and if Ai is an instance of a class C, then it is said that Ai satisfies Pi when C=Pi or when C is a subclass of Pi. If Pi is of the form (eql object), then it is said that Ai satisfies P when the function eql is applied to Ai and object is true.

Because a parameter spcializer is a type specifier, the function typep can be used during method selection to determine whether an argument satisfies a parameter specializer. In general a parameter specializer cannot be a type specifier list, such as (vector single-float). The only parameter specializer that can be a list is (eql object). This requires that Common LISP define the type specializer eql as if the following were evaluated:

A method all of whose parameter specializers are the class named t is called a default method; it is always applicable but may be shadowed by a more specific method.

Methods have qualifiers, which give the method combination procedure a way to distinguish among methods. A method that has one or more qualifiers is called a qualified method. A method with no qualifiers is called an unqualified method. A qualifier is any object other than a list, that is, any non-nil atom. The qualifiers defined by standard method combination and by the built-in method combination types are symbols.

In the specification, the terms primary methods and auxiliary method are used to partition methods within a method combination according to their intended use. In standard method combination, primary methods are unqualified methods, and auxiliary methods are methods with a single qualifier that is one of :around, :before, or :after. When a method combination type is defined using the short form of define-method-combination, primary methods are methods qualified with the name of the type of method combination, and auxiliary methods have the qualifier :around. Thus the terms primary method and auxiliary method have only a relative definition within a given method combination type.

Two methods are said to agree with one another on parameter specializers and qualifiers if the following conditions hold:

These rules define the congruence of a set of lambda-lists, including the lambda-list of each method for a given generic function and the lambda-list specified for the generic function itself, if given.

Each lambda-list must have the same number of required parameters.

If a method-defining form that cannot specify generic function options creates a generic function, and if the lambda-list for the method mentions keyword arguments, the lambda-list of the generic function will mention &key (but no keyword arguments).

When a generic function or any of its methods mentions &key in a lambda-list, the specific set of keyword arguments accepted by the generic function varies according to the applicable methods. The set of keyword arguments accepted by the generic function for a particular call is the union of the keyword arguments accepted by all applicable methods and the keyword arguments mentioned after &key in the generic function definition, if any. A method that has &rest but not &key doe not affect the set of acceptable keyword arguments. If the lambda-list of any applicable method or of the generic function definition contains &allow-other-keys, all keyword arguments are accepted by the generic function.

The lambda-list congruence rules require that each method accept all of the keyword arguments mentioned after &key in the generic function definition, by accepting them explicitly, by specifying &allow-other-keys, or by specifying &rest but not &key. Each method can accept additional keyword arguments of its own, in addition to the keyword arguments mentioned in the generic function definition.

If a generic function is passed a keyword argument that no applicable method accepts, an error is signaled.

For example, suppose there are two methods defined for width as follows:

Assume that there are no other methods and no generic function definition for width. The evaluation of the following form will signal an error because the keyword argument :pixel-size is not accepted by the applicable method.

The evaluation of the following form will signal an error:

The evaluation of the following form will not signal an error if the class named character-picture-class is a subclass of both picture-class and character-class.

When a generic function is called with particular arguments, it must determine the code to execute. This code is called the effective method for those arguments. The effective method is a combination of the applicable methods in the generic function. A combination of methods is a LISP expression that contains calls to some or all of the methods. If a generic function is called and no methods apply, the generic function no-applicable-method is invoked.

When the effective method has been determined, it is invoked with the same arguments that were passed to the generic function. Whatever values it returns are returned as the values of the generic function.

The effective method for a set of arguments is determined by the following three-step procedure:

1. Select the applicable methods

2. Sort the applicable methods by precedence order, putting the most specific method first.

3. Apply method combination to the sorted list of applicable methods, producing the effective method.

This step is described in 28.1.6.2.

To compare the precedence of two methods, their parameter specializers are examined in order. The default examination order is from left to right, but an alternative order may be specified by the :argument-precedence-order option to defgeneric or to any of the other forms that specify generic function options.

The corresponding parameter specializers from each method are compared. When a pair of parameter specializers are equal, the next pair are compared for equality. If all corresponding parameter specializers are equal, the two methods must have different qualifiers; in this case, either method can be selected to precede the other.

If some corresponding parameter specializers are not equal, the first pair of parameter specializers that are not equal determines the precedence. If both parameter specializers are classes, the more specific of the two methods is the method whose parameter specializer appears earlier in the class precedence list of the corresponding argument. Because of the way in which the set of applicable methods is chosen, the parameter specializers are guaranteed to be present in the class precedence list of the class of the argument.

If just one parameter specializer is (eql object), the method with that parameter specializer precedes the other method. If both parameter specializers are eql forms, the specializers must be the same (otherwise the two methods would not both have been applicable to this argument.)

The resulting list of applicable methods has the most specific method first and the least specific method last.

In the simple case--if standard method combination is used and all applicable methods are primary methods--the effective method is the most specific method. That method can call the next most specific method by using the function call-next-method. The method that call-next-method will call is referred to as the next method. The predicate next-method-p tests whether a next method exists. If call-next-method is called and there is no next most specific method, the generic function no-next-method is invoked.

In general, the effective method is some combination of the applicable methods. It is defined by a LISP form that contains calls to some or all of the applicable methods, returns the value or values that will be returned as the value or values of the generic function, and optionally makes some of the methods accessible by means of call-next-method. This LISP form is the body of the effective method; it is augmented with an appropriate lambda-list to make it a function.

The role of each method in the effective method is determined by its method qualifiers and the specificity of the method. A qualifier serves to mark a method, and the meaning of a qualifier is determined by the way that these marks are used by this step of the procedure. If an applicable method has an unrecognized qualifier, this step signals an error and does not include that method in the effective method.

When standard method combination is used together with qualified methods, the effective method is produced as described in section 28.1.7.2.

Standard method combination is supported by the class standard-generic-function. It is used if no other type of method combination is specified or if the built-in method combination standard is specified. [This is the only type of method combination currently supported by Star Sapphire CLOS].

Primary methods define the main action of the effective method, while auxiliary methods modify that action in one of three ways. A primary method has no method qualifiers.

An auxiliary method is a method whose method qualifier is :before, :after or :around. Standard method combination allows no more than one qualifier per method; if a method definition specifies more than one qualifier per method, an error is signaled.

NOTICE: Star Sapphire CLOS currently supports primary methods and :before and :after auxiliary methods; :around is NOT supported. Furthermore :before and :after have NOT been extensively tested.

A :before method has the keyword :before as its only qualifier. A :before method specifies code that is to be run before any primary method.

An :after method has the keyword :after as its only qualifier. An :around method specifies code that is to be run after primary methods.

The semantics of standard method combination (omitting the unimplemented :around method combination) are as follows:

All the :before methods are called, in most-specific- first order. Their values are ignored.

The most specific primary method is called.

All the :after methods are called, in most-specific-last

order. Their values are ignored.

In standard method combination, if there is an applicable method but no applicable primary method, an error is signaled.