Next: , Previous: Overview of Places and Generalized Reference, Up: Generalized Reference

5.1.2 Kinds of Places

Several kinds of places are defined by Common Lisp; this section enumerates them. This set can be extended by implementations and by programmer code. Variable Names as Places

The name of a lexical variable or dynamic variable can be used as a place. Function Call Forms as Places

A function form can be used as a place if it falls into one of the following categories: VALUES Forms as Places

A values form can be used as a place, provided that each of its subforms is also a place form.

A form such as

(setf (values place-1 ... place-n) values-form)

does the following:

  1. The subforms of each nested place are evaluated in left-to-right order.
  2. The values-form is evaluated, and the first store variable from each place is bound to its return values as if by multiple-value-bind.
  3. If the setf expansion for any place involves more than one store variable, then the additional store variables are bound to nil.
  4. The storing forms for each place are evaluated in left-to-right order.

The storing form in the setf expansion of values returns as multiple values2 the values of the store variables in step 2. That is, the number of values returned is the same as the number of place forms. This may be more or fewer values than are produced by the values-form. THE Forms as Places

A the form can be used as a place, in which case the declaration is transferred to the newvalue form, and the resulting setf is analyzed. For example,

 (setf (the integer (cadr x)) (+ y 3))

is processed as if it were

 (setf (cadr x) (the integer (+ y 3))) APPLY Forms as Places

The following situations involving setf of apply must be supported:

In all three cases, the element of array designated by the concatenation of subscripts and more-subscripts (i.e., the same element which would be read by the call to apply if it were not part of a setf form) is changed to have the value given by new-element. For these usages, the function name (aref, bit, or sbit) must refer to the global function definition, rather than a locally defined function.

No other standardized function is required to be supported, but an implementation may define such support. An implementation may also define support for implementation-defined operators.

If a user-defined function is used in this context, the following equivalence is true, except that care is taken to preserve proper left-to-right evaluation of argument subforms:

 (setf (apply #'name {arg}*) val)
 ≡ (apply #'(setf name) val {arg}*) Setf Expansions and Places

Any compound form for which the operator has a setf expander defined can be used as a place. The operator must refer to the global function definition, rather than a locally defined function or macro. Macro Forms as Places

A macro form can be used as a place, in which case Common Lisp expands the macro form as if by macroexpand-1 and then uses the macro expansion in place of the original place. Such macro expansion is attempted only after exhausting all other possibilities other than expanding into a call to a function named (setf reader). Symbol Macros as Places

A reference to a symbol that has been established as a symbol macro can be used as a place. In this case, setf expands the reference and then analyzes the resulting form. Other Compound Forms as Places

For any other compound form for which the operator is a symbol f, the setf form expands into a call to the function named (setf f). The first argument in the newly constructed function form is newvalue and the remaining arguments are the remaining elements of place. This expansion occurs regardless of whether f or (setf f) is defined as a function locally, globally, or not at all. For example,

(setf (f arg1 arg2 ...) new-value)

expands into a form with the same effect and value as

 (let ((#:temp-1 arg1)          ;force correct order of evaluation
       (#:temp-2 arg2)
       (#:temp-0 new-value))
   (funcall (function (setf f)) #:temp-0 #:temp-1 #:temp-2...))

A function named (setf f) must return its first argument as its only value in order to preserve the semantics of setf.