Next: Modify Macros, Up: Generalized Variables [Contents][Index]

#### 4.2.1 Setf Extensions

Several standard (e.g., `car`) and Emacs-specific (e.g., `window-point`) Lisp functions are `setf`-able by default. This package defines `setf` handlers for several additional functions:

- Functions from this package:

      cl-rest        cl-subseq      cl-get         cl-getf
      cl-caaar…cl-cddddr          cl-first…cl-tenth

  Note that for `cl-getf` (as for `nthcdr`), the list argument of the function must itself be a valid place form.

- General Emacs Lisp functions:

      buffer-file-name                   getenv
      buffer-modified-p                  global-key-binding
      buffer-name                        local-key-binding
      buffer-string                      mark
      buffer-substring                   mark-marker
      current-buffer                     marker-position
      current-case-table                 mouse-position
      current-column                     point
      current-global-map                 point-marker
      current-input-mode                 point-max
      current-local-map                  point-min
      current-window-configuration       read-mouse-position
      default-file-modes                 screen-height
      documentation-property             screen-width
      face-background                    selected-window
      face-background-pixmap             selected-screen
      face-font                          selected-frame
      face-foreground                    standard-case-table
      face-underline-p                   syntax-table
      file-modes                         visited-file-modtime
      frame-height                       window-height
      frame-parameters                   window-width
      frame-visible-p                    x-get-secondary-selection
      frame-width                        x-get-selection
      get-register

  Most of these have directly corresponding “set” functions, like `use-local-map` for `current-local-map`, or `goto-char` for `point`. A few, like `point-min`, expand to longer sequences of code when they are used with `setf` (`(narrow-to-region x (point-max))` in this case).

- A call of the form `(substring subplace n [m])`, where subplace is itself a valid generalized variable whose current value is a string, and where the value stored is also a string. The new string is spliced into the specified part of the destination string. For example:

      (setq a (list "hello" "world"))
           ⇒ ("hello" "world")
      (cadr a)
           ⇒ "world"
      (substring (cadr a) 2 4)
           ⇒ "rl"
      (setf (substring (cadr a) 2 4) "o")
           ⇒ "o"
      (cadr a)
           ⇒ "wood"
      a
           ⇒ ("hello" "wood")

  The generalized variable `buffer-substring`, listed above, also works in this way by replacing a portion of the current buffer.

- A macro call, in which case the macro is expanded and `setf` is applied to the resulting form.

The `setf` macro takes care to evaluate all subforms in the proper left-to-right order; for example,

    (setf (aref vec (cl-incf i)) i)

looks like it will evaluate `(cl-incf i)` exactly once, before the following access to `i`; the `setf` expander will insert temporary variables as necessary to ensure that it does in fact work this way no matter what setf-method is defined for `aref`. (In this case, `aset` would be used and no such steps would be necessary since `aset` takes its arguments in a convenient order.)

However, if the place form is a macro which explicitly evaluates its arguments in an unusual order, this unusual order will be preserved. Adapting an example from Steele, given

    (defmacro wrong-order (x y) (list 'aref y x))

the form `(setf (wrong-order a b) 17)` will evaluate b first, then a, just as in an actual call to `wrong-order`.

Next: Modify Macros, Up: Generalized Variables [Contents][Index]