The special form
declare behaves computationally as if it is not present (other than to affect the semantics), and is only allowed in certain contexts, such as after the variable list in a
defun and so on.
There are three distinct uses of
declare: one is to declare Lisp variables as "special" (this affects the semantics of the appropriate bindings of the variables), the second is to provide advice to help the Common Lisp system (in reality the compiler) run your Lisp code faster or with more sophisticated debugging options, and the third (using the
:explain declaration) is to help you optimize your code.
If you use
declare to specify types (and so eliminate type-checking for the specified symbols) and then supply the wrong type, you may obtain a "Segmentation Violation". You can check this by interpreting the code (rather than compiling it).
hcl:special-globaldeclares that the symbol is never bound.
hcl:special-global is very useful, and because of the checks it is reasonably safe. It is useful not only for speed, but also to guard against unintentionally binding variables that should not be bound.
See also defglobal-parameter.
hcl:special-dynamicdeclares that the symbol is never accessed outside the dynamic scope of the binding.
hcl:special-fast-accessdeclares that a symbol should be "fast access".
The semantics of the declaration is the same as
cl:special, except that access to the variable is low safety. In addition, the compiler compiles access to the symbol in a way that speeds up the access, but also introduces a tiny reduction in the speed of the whole system. The balance between these effects is not obvious.
hcl:lambda-listspecifies the value to be returned when a programmer asks for the arglist of a function.
valuesspecifies the value to be returned when you ask for a description of the results of a function.
hcl:invisible-framespecifies that calls to this function should not appear in a debugger backtrace.
hcl:aliasspecifies that calls to this function should be displayed as calls to an alternative function in a debugger backtrace.
hcl:lambda-namedeclares the name of the surrounding lambda.
:explaincontrols messages printed by the compiler while it is processing forms.
You can also use define-declaration to add your own declarations, which do not affect compilation but are useful for code walkers.
This section documents the
hcl:lambda-name declaration, which declares the name of the surrounding lambda. This declaration is useful only for a lambda that becomes a standalone function, that is lambda forms that are passed to
The dspec of the function that is returned by
function is specified by the second element in the declaration. In the special case when the second element is a two-element list starting with the symbol
subfunction, the dspec is that list with the dspec of the parent function added as a third element. For example, if you have:
defun, (that is creating a "top-level" function at load-time). In this case, you should also use def to be able to locate the source. For example, look at the output of
(function (lambda ..))). In this case, you should be using the
)form above, so the recorded name contains the dspec of the parent function, otherwise the debugger will not be able to find the source from the subfunction.
Naming functions and subfunctions is useful because it makes it easier to understand the flow of control when you see them in a backtrace. For subfunctions, it makes it easier to trace and advise them (see trace and defadvice).
optionkey ::= :none | :variables | :types | :floats | :non-floats | :all-calls | :all-calls-with-arg-types | :calls | :boxing | :print-original-form | :print-expanded-form | :print-length | :print-level
:explain declaration controls messages printed by the compiler while it is processing forms. The declaration can be used with proclaim or declaim as a top level form to give it global or file scope. It can also be used at the start of a
#'lambda form or function body to give it the scope of that function. The declaration has unspecified effect when used in other contexts, for example in the body of a
:explain declaration consists of a set of options of the form
) which associates optionvalue with optionkey or optionkey which associates
t with optionkey. By default, all of the optionkeys have an associated value
nil. All optionkeys not specified by a declaration remain unchanged (except for the special action of the
:none optionkey described below).
Set value associated with all optionkeys to
nil. This turns off all explanations.
If optionvalue is non-nil, list all the variables of each function, specifying whether they are floating point or not.
If optionvalue is non-nil, print information about compiler transformations that depend on declared or deduced type information.
If optionvalue is non-nil, print information about calls to functions that may allocate floats.
If optionvalue is non-nil, print information about calls to functions that may allocate non-float numbers, for example bignums.
If optionvalue is non-nil, print information about calls to normal functions.
A synonym for
If optionvalue is non-nil, print information about calls to functions that may allocate numbers, for example floats or bignums.
Use the optionvalue as the value of
Use the optionvalue as the value of
LispWorks User Guide and Reference Manual - 20 Sep 2017