123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636 |
- % -*- Mode: TeX -*-
- %%2.5 objects
-
- The \term{generic function} \funref{make-instance} creates and returns a new
- \term{instance} of a \term{class}. The first argument is a \term{class} or
- the \term{name} of a \term{class}, and the remaining arguments form an
- \newterm{initialization argument list}.
- The initialization of a new \term{instance} consists of several distinct
- steps, including the following: combining the explicitly supplied initialization
- arguments with default values for the unsupplied initialization arguments,
- checking the validity of the initialization arguments, allocating storage
- for the \term{instance}, filling \term{slots} with
- values, and executing user-supplied \term{methods} that perform additional
- initialization. Each step of \funref{make-instance} is implemented by a
- \term{generic function} to provide a mechanism for customizing that step.
- In addition, \funref{make-instance} is itself a \term{generic function}
- and thus also can be customized.
- The \OS\ specifies system-supplied primary \term{methods} for each step
- and thus specifies a well-defined standard behavior for the entire
- initialization process. The standard behavior provides four simple
- mechanisms for controlling initialization:
- \beginlist
- \itemitem{\bull} Declaring a \term{symbol} to be an initialization argument
- for a \term{slot}. An initialization argument is declared by using the
- \kwd{initarg} slot option to \macref{defclass}. This provides a mechanism
- for supplying a value for a \term{slot} in a call to \funref{make-instance}.
- \itemitem{\bull} Supplying a default value form for an initialization argument.
- Default value forms for initialization arguments are defined by using the
- \kwd{default-initargs} class option to \macref{defclass}. If an
- initialization argument is not explicitly provided
- as an argument to \funref{make-instance}, the default value form is
- evaluated in the lexical environment of the \macref{defclass} form that
- defined it, and the resulting value is used as the value of the
- initialization argument.
- \itemitem{\bull} Supplying a default initial value form for a \term{slot}.
- A default initial value form for a \term{slot} is defined by using the
- \kwd{initform} slot option to \macref{defclass}. If no initialization
- argument associated with that \term{slot} is given as an argument to
- \funref{make-instance} or is defaulted by \kwd{default-initargs}, this
- default initial value form is evaluated in the lexical environment of
- the \macref{defclass} form that defined it, and the resulting value is
- stored in the \term{slot}. The \kwd{initform} form for a
- \term{local slot} may be used when creating an \term{instance}, when
- updating an \term{instance} to conform to a redefined \term{class},
- or when updating an \term{instance} to conform to the definition of a
- different \term{class}. The \kwd{initform} form for a
- \term{shared slot} may be used when defining or re-defining the \term{class}.
-
- \itemitem{\bull}
- Defining \term{methods} for \funref{initialize-instance} and
- \funref{shared-initialize}. The slot-filling behavior described above is
- implemented by a system-supplied primary \term{method} for
- \funref{initialize-instance} which invokes \funref{shared-initialize}. The
- \term{generic function} \funref{shared-initialize} implements the parts of
- initialization shared by these four situations: when making an \term{instance},
- when re-initializing an \term{instance}, when updating an \term{instance}
- to conform to a redefined \term{class}, and when updating an \term{instance}
- to conform to the definition of a different \term{class}. The system-supplied
- primary \term{method} for \funref{shared-initialize} directly implements the
- slot-filling behavior described above, and \funref{initialize-instance}
- simply invokes \funref{shared-initialize}.
- \endlist
- \beginsubsection{Initialization Arguments}
- An initialization argument controls \term{object} creation and
- initialization. It is often convenient to use keyword \term{symbols}
- to name initialization arguments, but the \term{name} of an
- initialization argument can be any \term{symbol}, including \nil. An
- initialization argument can be used in two ways: to fill a \term{slot}
- with a value or to provide an argument for an initialization
- \term{method}. A single initialization argument can be used for both
- purposes.
- \issue{PLIST-DUPLICATES:ALLOW}
- An \term{initialization argument list} is a
- %list of alternating of
- \term{property list} of
- initialization argument names and values.
- Its structure is identical
- to a \term{property list} and also
- to the portion of an argument list
- processed for \keyref{key} parameters.
- As in those lists,
- if an initialization
- argument name appears more than once in an initialization argument list,
- the leftmost occurrence supplies the value and the remaining occurrences
- are ignored. The arguments to \funref{make-instance} (after the first
- argument) form an \term{initialization argument list}.
- \issue{INITIALIZATION-FUNCTION-KEYWORD-CHECKING}
- % Error-checking
- % of initialization argument names is disabled if the keyword argument
- % pair whose keyword is \kwd{allow-other-keys} and whose value is
- % \term{non-nil} appears in the \term{initialization argument list}.
- \endissue{INITIALIZATION-FUNCTION-KEYWORD-CHECKING}
- \endissue{PLIST-DUPLICATES:ALLOW}
- An initialization argument can be associated with a \term{slot}. If
- the initialization argument has a value in the \term{initialization
- argument list}, the value is stored into the \term{slot} of the newly
- created \term{object}, overriding any \kwd{initform} form associated
- with the \term{slot}. A single initialization argument can initialize
- more than one \term{slot}. An initialization argument that initializes
- a \term{shared slot} stores its value into the \term{shared slot},
- replacing any previous value.
- An initialization argument can be associated with a \term{method}. When
- an \term{object} is created and a particular initialization argument is
- supplied, the \term{generic functions} \funref{initialize-instance},
- \funref{shared-initialize}, and \funref{allocate-instance} are called
- with that initialization argument's name and value as a keyword argument
- pair. If a value for the initialization argument is not supplied in the
- \term{initialization argument list}, the \term{method}'s
- \term{lambda list} supplies a default value.
- Initialization arguments are used in four situations: when making an
- \term{instance}, when re-initializing an \term{instance}, when updating
- an \term{instance} to conform to a redefined \term{class}, and when
- updating an \term{instance} to conform to the definition of a different
- \term{class}.
- Because initialization arguments are used to control the creation and
- initialization of an \term{instance} of some particular \term{class},
- we say that an initialization argument is
- ``an initialization argument for'' that \term{class}.
- \endsubsection%{Initialization Arguments}
- \beginsubsection{Declaring the Validity of Initialization Arguments}
- \DefineSection{DeclaringInitargValidity}
- Initialization arguments are checked for validity in each of the four
- situations that use them. An initialization argument may be valid in
- one situation and not another. For example, the system-supplied
- primary \term{method} for \funref{make-instance} defined for
- \theclass{standard-class} checks the validity of its initialization arguments
- and signals an error if an initialization argument is supplied that is
- not declared as valid in that situation.
- There are two means for declaring initialization arguments valid.
- \beginlist
- \itemitem{\bull}
- Initialization arguments that fill \term{slots} are declared as valid
- by the \kwd{initarg} slot option to \macref{defclass}. The
- \kwd{initarg} slot option is inherited from \term{superclasses}. Thus
- the set of valid initialization arguments that fill \term{slots} for a
- \term{class} is the union of the initialization arguments that fill
- \term{slots} declared as valid by that \term{class} and its
- \term{superclasses}. Initialization arguments that fill \term{slots}
- are valid in all four contexts.
- \itemitem{\bull}
- Initialization arguments that supply arguments to \term{methods} are
- declared as valid by defining those \term{methods}. The keyword name of
- each keyword parameter specified in the \term{method}'s
- \term{lambda list} becomes an initialization argument for all \term{classes}
- for which the \term{method} is applicable.
- \issue{INITIALIZATION-FUNCTION-KEYWORD-CHECKING}
- The presence of {\allowotherkeys} in the
- \term{lambda list} of an applicable method disables validity checking of
- initialization arguments.
- \endissue{INITIALIZATION-FUNCTION-KEYWORD-CHECKING}
- Thus \term{method} inheritance
- controls the set of valid initialization arguments that supply arguments
- to \term{methods}. The \term{generic functions} for which \term{method}
- definitions serve to declare initialization arguments valid are as
- follows:
- \beginlist
- \itemitem{--}
- Making an \term{instance} of a \term{class}:
- \funref{allocate-instance}, \funref{initialize-instance}, and
- \funref{shared-initialize}. Initialization arguments declared as valid
- by these \term{methods} are valid when making
- an \term{instance} of a \term{class}.
- \itemitem{--} Re-initializing an \term{instance}:
- \funref{reinitialize-instance} and \funref{shared-initialize}.
- Initialization arguments declared as valid by these \term{methods} are
- valid when re-initializing an \term{instance}.
- \itemitem{--} Updating an \term{instance} to conform to a redefined \term{class}:
- \funref{update-instance-for-redefined-class} and \funref{shared-initialize}.
- Initialization arguments declared as valid by these \term{methods} are
- valid when updating an \term{instance} to conform to a redefined \term{class}.
- \itemitem{--} Updating an \term{instance} to conform to the definition of a
- different \term{class}:
- \funref{update-instance-for-different-class} and \funref{shared-initialize}.
- Initialization arguments declared as valid by these \term{methods} are
- valid when updating an \term{instance} to conform to the definition
- of a different \term{class}.
- \endlist
- \endlist
- The set of valid initialization arguments for a \term{class} is the set of
- valid initialization arguments that either fill \term{slots} or supply
- arguments to \term{methods}, along with the predefined initialization
- argument \kwd{allow-other-keys}. The default value for
- \kwd{allow-other-keys} is \nil.
- \issue{INITIALIZATION-FUNCTION-KEYWORD-CHECKING}
- % The meaning of
- % \kwd{allow-other-keys} is the same as when it is passed to an ordinary
- % \term{function}.
- Validity checking of initialization arguments is disabled if the value of
- the initialization argument \kwd{allow-other-keys} is \term{true}.
- \endissue{INITIALIZATION-FUNCTION-KEYWORD-CHECKING}
- \endsubsection%{Declaring the Validity of Initialization Arguments}
- \beginsubsection{Defaulting of Initialization Arguments}
- A default value \term{form} can be supplied for an initialization
- argument by using the \kwd{default-initargs} \term{class} option. If an
- initialization argument is declared valid by some particular \term{class},
- its default value form might be specified by a different \term{class}.
- In this case \kwd{default-initargs} is used to supply a default value
- for an inherited initialization argument.
- The \kwd{default-initargs} option is used only to provide default
- values for initialization arguments; it does not declare a \term{symbol}
- as a valid initialization argument name. Furthermore,
- the \kwd{default-initargs} option is used only to provide default values for
- initialization arguments when making an \term{instance}.
-
- The argument to the \kwd{default-initargs} class
- option is a list of
- alternating initialization argument names and \term{forms}.
- Each \term{form} is the
- default value form for the corresponding initialization
- argument. The default value \term{form} of an initialization
- argument is used and evaluated only if that initialization argument
- does not appear in the arguments to \funref{make-instance} and is not
- defaulted by a more specific \term{class}. The default value \term{form} is
- evaluated in the lexical environment of the \macref{defclass} form that
- supplied it; the resulting value is used as the initialization
- argument's value.
-
- The initialization arguments supplied to \funref{make-instance} are combined
- with defaulted initialization arguments to produce a
- \term{defaulted initialization argument list}. A
- \term{defaulted initialization argument list}
- is a list of alternating initialization argument names and
- values in which unsupplied initialization arguments are defaulted and in
- which the explicitly supplied initialization arguments appear earlier in
- the list than the defaulted initialization arguments. Defaulted
- initialization arguments are ordered according to the order in the
- \term{class precedence list} of the \term{classes} that supplied the default values.
-
- There is a distinction between the purposes of the
- \kwd{default-initargs} and the \kwd{initform} options with respect to the
- initialization of \term{slots}. The \kwd{default-initargs}
- class option
- provides a mechanism for the user to give a default value \term{form}
- for an initialization argument without knowing whether the
- initialization argument initializes a \term{slot}
- or is passed to a \term{method}.
- If that initialization argument is not explicitly supplied in a call
- to \funref{make-instance}, the default value \term{form} is used, just
- as if it had been supplied in the call. In contrast, the
- \kwd{initform} slot option provides a mechanism for the user to give a
- default initial value form for a \term{slot}. An \kwd{initform} form is
- used to initialize a \term{slot} only if no initialization argument
- associated with that \term{slot} is given as an argument to
- \funref{make-instance} or is defaulted by \kwd{default-initargs}.
- \idxtext{order of evaluation}\idxtext{evaluation order}
- The order of evaluation of default value \term{forms} for initialization
- arguments and the order of evaluation of \kwd{initform} forms are
- undefined. If the order of evaluation is important,
- \funref{initialize-instance} or \funref{shared-initialize} \term{methods}
- should be used
- instead.
- \endsubsection%{Defaulting of Initialization Arguments}
- \beginsubsection{Rules for Initialization Arguments}
- \DefineSection{InitargRules}
-
- The \kwd{initarg} slot option may be specified more than
- once for a given \term{slot}.
- The following rules specify when initialization arguments may be
- multiply defined:
- \beginlist
- \itemitem{\bull} A given initialization argument can be used to
- initialize more than one \term{slot} if the same initialization argument name
- appears in more than one \kwd{initarg} slot option.
- \itemitem{\bull} A given initialization argument name can appear
- in the \term{lambda list} of more than one initialization \term{method}.
- \itemitem{\bull} A given initialization argument name can
- appear both in an \kwd{initarg} slot option and
- in the \term{lambda list}
- of an initialization \term{method}.
- \endlist
- \reviewer{The next three paragraphs could be replaced by ``If two or more
- initialization arguments that initialize the same slot appear in the
- \term{defaulted initialization argument list}, the leftmost of these supplies
- the value, even if they have different names.'' And the rest would follow
- from the rules above.}
- If two or more initialization arguments that initialize the same
- \term{slot} are given in the arguments to \funref{make-instance}, the
- leftmost of these initialization arguments in the \term{initialization
- argument list} supplies the value, even if the initialization arguments
- have different names.
- If two or more different initialization arguments that initialize the
- same \term{slot} have default values and none is given explicitly in the
- arguments to \funref{make-instance}, the initialization argument that
- appears in a \kwd{default-initargs} class option in the most specific
- of the \term{classes} supplies the value. If a single
- \kwd{default-initargs} class option specifies two or more initialization
- arguments that initialize the same \term{slot} and none is given
- explicitly in the arguments to \funref{make-instance}, the leftmost in
- the \kwd{default-initargs} class option supplies the value, and the
- values of the remaining default value \term{forms} are ignored.
- Initialization arguments given explicitly in the arguments to
- \funref{make-instance} appear to the left of defaulted initialization
- arguments. Suppose that the classes $C\sub 1$ and $C\sub 2$ supply the
- values of defaulted initialization arguments for different \term{slots},
- and suppose that $C\sub 1$ is more specific than $C\sub 2$; then the
- defaulted initialization argument whose value is supplied by $C\sub 1$
- is to the left of the defaulted initialization argument whose value is
- supplied by $C\sub 2$ in the \term{defaulted initialization argument
- list}. If a single \kwd{default-initargs} class option supplies the
- values of initialization arguments for two different \term{slots}, the
- initialization argument whose value is specified farther to the left in
- the \kwd{default-initargs} class option appears farther to the left in
- the \term{defaulted initialization argument list}.
- \reviewer{Barmar: End of claim made three paragraphs back.}
-
- If a \term{slot} has both an \kwd{initform} form and an
- \kwd{initarg} slot option, and the initialization argument is defaulted
- using \kwd{default-initargs} or is supplied to \funref{make-instance},
- the captured \kwd{initform} form is neither used nor evaluated.
- The following is an example of the above rules:
- \code
- (defclass q () ((x :initarg a)))
- (defclass r (q) ((x :initarg b))
- (:default-initargs a 1 b 2))
- \endcode
- $$\vbox{\halign{\strut#\hfil&\quad\hfil#\hfil&\quad\hfil#\hfil\cr
- {}&\bf Defaulted&{}\cr
- \bf Form&\bf Initialization Argument List&\bf Contents of Slot X\cr
- \noalign{\hrule}
- {\tt (make-instance 'r)}&{\tt (a 1 b 2)}&{\tt 1}\cr
- {\tt (make-instance 'r 'a 3)}&{\tt (a 3 b 2)}&{\tt 3}\cr
- {\tt (make-instance 'r 'b 4)}&{\tt (b 4 a 1)}&{\tt 4}\cr
- {\tt (make-instance 'r 'a 1 'a 2)}&{\tt (a 1 a 2 b 2)}&{\tt 1}\cr}}$$
- \endsubsection%{Rules for Initialization arguments}
- \beginsubsection{Shared-Initialize}
- \DefineSection{SharedInitialize}
-
- The \term{generic function} \funref{shared-initialize} is used to fill the
- \term{slots}
- of an \term{instance}
- using initialization arguments and \kwd{initform}
- forms when an \term{instance} is created, when an
- \term{instance} is re-initialized,
- when an \term{instance}
- is updated to conform to a redefined \term{class}, and when
- an \term{instance} is updated to conform to a different \term{class}.
- It uses
- standard \term{method} combination. It takes the following arguments: the
- \term{instance} to be initialized, a
- specification of a set of \term{names} of \term{slots}
- \term{accessible} in that \term{instance}, and any number of initialization
- arguments. The arguments after the first two must form an
- \term{initialization argument list}.
-
- The second argument to \funref{shared-initialize} may be one of the following:
- \beginlist
- \itemitem{\bull} It can be a (possibly empty) \term{list} of \term{slot} names,
- which specifies the set of those \term{slot} names.
- % \reviewer{Barmar: This next bullet item is redundant with the previous,
- % since NIL -is- a LIST. If there was some confusion, we could say ``(possibly empty)''
- % in the previous item.}
- %
- % \itemitem{\bull} It can be \nil, which specifies the empty set of
- % \term{slot} names.
- \itemitem{\bull} It can be the symbol \t, which specifies the set of all of the \term{slots}.
- \endlist
-
- There is a system-supplied primary \term{method} for \funref{shared-initialize}
- whose first \term{parameter specializer} is \theclass{standard-object}.
- This \term{method} behaves as follows on each \term{slot},
- whether shared or local:
- \beginlist
- \itemitem{\bull} If an initialization argument in the
- \term{initialization argument list} specifies a value for that \term{slot},
- that value is stored
- into the \term{slot}, even if a value has already been stored in the \term{slot}
- before the \term{method} is run.
- The affected \term{slots} are independent of which
- \term{slots} are indicated by the second argument to \funref{shared-initialize}.
- \itemitem{\bull} Any \term{slots}
- indicated by the second argument that are still
- unbound at this point are initialized according to their
- \kwd{initform} forms. For any such \term{slot}
- that has an \kwd{initform} form,
- that \term{form} is evaluated in the
- lexical environment of its defining
- \macref{defclass} form and the result is stored into the \term{slot}.
- For example,
- if a \term{before method} stores a value in the
- \term{slot}, the \kwd{initform} form will not be used to supply a value
- for the \term{slot}. If
- the second argument specifies a \term{name} that does not correspond to any
- \term{slots} \term{accessible}
- in the \term{instance}, the results are unspecified.
- \itemitem{\bull} The rules mentioned in {\secref\InitargRules} are obeyed.
- \endlist
-
- The generic function \funref{shared-initialize} is called by the
- system-supplied primary \term{methods}
- for \funref{reinitialize-instance},
- \funref{update-instance-for-different-class},
- \funref{update-instance-for-redefined-class}, and
- \funref{initialize-instance}. Thus, \term{methods} can be written for
- \funref{shared-initialize} to specify actions that should be taken in all of
- these contexts.
- \endsubsection%{Shared-Initialize}
- \beginsubsection{Initialize-Instance}
-
- The \term{generic function} \funref{initialize-instance} is called by
- \funref{make-instance} to initialize a newly created \term{instance}.
- It uses \term{standard method combination}. \term{Methods} for
- \funref{initialize-instance} can be defined in order to perform any
- initialization that cannot be achieved
- %%This was the only case of a half-glossary-term in the entire spec. -kmp 1-Jan-91
- %with the simple \term{slot}-filling mechanisms.
- simply by supplying initial values for \term{slots}.
-
- During initialization, \funref{initialize-instance} is invoked
- after the following actions have been taken:
- \beginlist
- \itemitem{\bull} The \term{defaulted initialization argument list}
- has been computed by combining the supplied \term{initialization argument list}
- with any default initialization arguments for the \term{class}.
- \itemitem{\bull} The validity of the \term{defaulted initialization argument list}
- has been checked. If any of the initialization arguments has not
- been declared as valid, an error is signaled.
- \itemitem{\bull} A new \term{instance} whose \term{slots}
- are unbound has been created.
- \endlist
-
- The generic function \funref{initialize-instance} is called with the
- new \term{instance} and the defaulted initialization arguments. There is
- a system-supplied primary \term{method} for \funref{initialize-instance}
- whose \term{parameter specializer} is \theclass{standard-object}. This
- \term{method} calls the generic function
- \funref{shared-initialize} to fill in
- the \term{slots} according to the initialization arguments and the
- \kwd{initform} forms for the \term{slots}; the generic function
- \funref{shared-initialize} is called with the following arguments: the \term{instance},
- \t, and the defaulted initialization arguments.
-
- Note that \funref{initialize-instance} provides the
- \term{defaulted initialization argument list} in its call to \funref{shared-initialize},
- so the first step performed by the system-supplied primary \term{method} for
- \funref{shared-initialize} takes into account both the initialization
- arguments provided in the call to \funref{make-instance} and the
- \term{defaulted initialization argument list}.
- \term{Methods} for \funref{initialize-instance} can be defined to specify
- actions to be taken when an \term{instance} is initialized.
- If only \term{after methods} for \funref{initialize-instance} are defined, they will be
- run after the system-supplied primary \term{method} for initialization and
- therefore will not interfere with the default behavior of
- \funref{initialize-instance}.
- The \OS\ provides two \term{functions} that are useful in the bodies of
- \funref{initialize-instance} methods. \Thefunction{slot-boundp}
- returns a \term{generic boolean} value that indicates whether a specified \term{slot} has a
- value; this provides a mechanism for writing \term{after methods} for
- \funref{initialize-instance} that initialize \term{slots} only if they have
- not already been initialized. \Thefunction{slot-makunbound}
- causes the \term{slot} to have no value.
- \endsubsection%{INITIALIZE-INSTANCE}
- \beginsubsection{Definitions of Make-Instance and Initialize-Instance}
-
- The generic function \funref{make-instance} behaves as if it were defined as
- follows, except that certain optimizations are permitted:
- \code
- (defmethod make-instance ((class standard-class) &rest initargs)
- ...
- (let ((instance (apply #'allocate-instance class initargs)))
- (apply #'initialize-instance instance initargs)
- instance))
- (defmethod make-instance ((class-name symbol) &rest initargs)
- (apply #'make-instance (find-class class-name) initargs))
- \endcode
- %This is the code:
- %(defmethod make-instance ((class standard-class) &rest initargs)
- % (setq initargs (default-initargs class initargs))
- % (let* ((proto (class-prototype class))
- % (methods
- % (append
- % (compute-applicable-methods #'allocate-instance `(,class))
- % (compute-applicable-methods #'initialize-instance `(,proto))
- % (compute-applicable-methods #'shared-initialize `(,proto nil)))))
- % (unless
- % (subsetp
- % (let ((keys '()))
- % (do ((plist initargs (cddr plist)))
- % ((null plist) keys)
- % (push (car plist) keys)))
- % (union
- % (class-slot-initargs class)
- % (reduce #'union (mapcar #'function-keywords methods))))
- % (error ...)))
- % (let ((instance (apply #'allocate-instance class initargs)))
- % (apply #'initialize-instance instance initargs)
- % instance))
-
- The elided code in the definition of \funref{make-instance}
- %% Per X3J13. -kmp 05-Oct-93
- augments the \f{initargs} with any \term{defaulted initialization arguments} and
- checks the
- %% Per X3J13. -kmp 05-Oct-93
- %supplied
- resulting
- initialization arguments to determine whether an initialization
- argument was supplied that neither filled a \term{slot} nor supplied an argument
- to an applicable \term{method}.
- %This check could be implemented using the generic functions
- % ???\funref{class-prototype},??? \funref{compute-applicable-methods},
- %\funref{function-keywords}, and ???\funref{class-slot-initargs}. ???
- %See Chapter~3 for a
- %description of this initialization argument check.
-
- The generic function \funref{initialize-instance} behaves as if it were
- defined as follows, except that certain optimizations are permitted:
- \code
- (defmethod initialize-instance ((instance standard-object) &rest initargs)
- (apply #'shared-initialize instance t initargs)))
- \endcode
- % Barmar complains that "Programmer Interface level" is not defined.
- % Presumably it means "this specification".
- % Ditto "the meta-object level" is not defined.
- % Presumably it should just be omitted as beyond the scope of this standard,
- % or else we should define the term somewhere (e.g., the glossary).
- % I decided to just trim it down to where glossary words weren't needed. -kmp 6-Jan-91
- These procedures can be customized.
- % at either the Programmer Interface level,
- % the meta-object level, or both.
-
- Customizing at the Programmer Interface level includes using the
- \kwd{initform}, \kwd{initarg}, and \kwd{default-initargs} options to
- \macref{defclass}, as well as defining \term{methods}
- for \funref{make-instance},
- %% Per X3J13. -kmp 05-Oct-93
- \funref{allocate-instance},
- and \funref{initialize-instance}. It is also possible to define
- \term{methods} for \funref{shared-initialize}, which would be invoked by the
- generic functions \funref{reinitialize-instance},
- \funref{update-instance-for-redefined-class},
- \funref{update-instance-for-different-class}, and
- \funref{initialize-instance}.
- The meta-object level supports additional
- customization.
- %by allowing methods to be defined on \funref{make-instance},
- %???\b{default-initargs}???, and \funref{allocate-instance}.
- %Chapters~2 and~3 document each of these generic
- %functions and the system-supplied primary methods.
-
- Implementations are permitted to make certain optimizations to
- \funref{initialize-instance} and \funref{shared-initialize}.
- The description of \funref{shared-initialize} in Chapter~7 mentions the
- possible optimizations.
- %Because of optimization, the check for valid initialization arguments
- %might not be implemented using the generic functions
- %???\funref{class-prototype},???
- %\funref{compute-applicable-methods}, \funref{function-keywords}, and
- %???\funref{class-slot-initargs}???. In addition,
- %methods for the generic function
- %???\funref{default-initargs},??? and the
- %system-supplied primary methods for
- %???\funref{allocate-instance}???,
- %\funref{initialize-instance}, and \funref{shared-initialize} might not be called on
- %every call to \funref{make-instance} or might not receive exactly the
- %arguments that would be expected.
- \endsubsection%{Definitions of MAKE-INSTANCE and Initialize-Instance}
|