I saw things like appendf in alexandria. (appendf a b)
can be replaced with (a sligtly more verbose, but more general)

(arg1f append a b), where

(defmacro arg1f (function place &rest args)
               `(setf ,place (,function ,place ,@args)))

and, maybe,

(defmacro arg2f (function arg1 place &rest args)
               `(setf ,place (,function ,arg1 ,place ,@args)))

* budden <9ffc6738-4b71-48e1-887f-1e100b094...@k19g2000yqc.googlegroups.com> :
Wrote on Tue, 3 Nov 2009 02:26:38 -0800 (PST):

| (defmacro arg2f (function arg1 place &rest args)
|                `(setf ,place (,function ,arg1 ,place ,@args)))
|
| Maybe there is a good traditional name for arg1f already?

[Without endorsing this style]

See C-h f callf and C-h f callf2
in an Emacs near you.

,---- callf is a Lisp macro in `cl-macs.el'.
|
| (callf FUNC PLACE ARGS...)
|
| Set PLACE to (FUNC PLACE ARGS...).
| FUNC should be an unquoted function name.  PLACE may be a symbol,
| or any generalized variable allowed by `setf'.
`----

,---- callf2 is a Lisp macro in `cl-macs.el'.
|
| (callf2 FUNC ARG1 PLACE ARGS...)
|
| Set PLACE to (FUNC ARG1 PLACE ARGS...).
| Like `callf', but PLACE is the second argument of FUNC, not the first.
`----

(defmacro _f (op place &rest args)
  "Macro from @cite{(Graham 1993)}.  Turns the operator @arg{op} into a
modifying form, e.g. @code{(_f + a b) @equiv{} (incf a b)}."
  (multiple-value-bind (vars forms var set access)
      (get-setf-expansion place)
    `(let* (,@(mapcar #'list vars forms)
            (,(car var) (,op ,access ,@args)))
       ,set)))

(modify-using append a b)

Pascal

(defmacro _2f (op arg1 place &rest args)
  "Like _f, but place is a second argument of op"
  (multiple-value-bind (vars forms var set access)
      (get-setf-expansion place)
    `(let* (,@(mapcar #'list vars forms)
            (,(car var) (,op ,arg1 ,access ,@args)))
       ,set)))

Pascal

  (setf a (append a b))

You've traded clarity for obfuscation, for three lousy characters.

  (setf a (append a b))

to obtain the effect of this:

  (setf a (append a b))

(_f append (bar-accessor (session-value 'foo)) '(hello))

 (_f (frob b (append c _ d) e)  (bar-accessor (session-value 'foo)))

perhaps?

   (setf a (frob b (append c (nicate a) d) e)) ?

There is no side effect if you evaluate a simple variable twice.  In fact you
can't avoid that. An update requires two accesses: read and write.

These ``F'' macros ensure that there are no additional redundant accesses.  On
the read access, the place is reduced to some object which can then be passed
to a store form to update that place without any additional evaluation.

So the interesting case arises when we replace your A by some big
expression:

   (setf (BIG EXPR ...) (frob b (append c (nicate (BIG EXPR ...)) d) e)) ?

  (patternsdf-update (frob

  (update ((var1 place1)
           (var2 place2)
           ...
           (varN placeN))
    ...
    ...
    ... any number of forms involving var1 through varN as sources
    ... of values, as well as targets of assignments.
    ...
    ...)

UPDATE asserts that N places are to be updated.  The bodies of the construct
refer to the places using names var1 through varN. Each place is accessed
without evaluating the place expression twice.

The update works like this, in the abstract semantics: prior to the execution
of the body, the places are converted into load forms, which are accessed once
to retrieve the values of the variables.  The action in the body happens using
the variables. When the body terminates, the update is committed using the
corresponding store forms.

If the body terminates by a non-local exit, then the update is
aborted. It's implementation-defined how many of the places have been
accessed by that point (we'd like to be able to optimize by interleaving
some of the accesses into the evaluation of the body, but no place is updated
until the body terminates properly). The places are updated in order; if
the store form for placeM terminates with a nonlocal exit, then places
1 thorugh M-1 are updated, but M through N are not updated.

Furthermore, introducing UPDATE*:

  (update* ((var1 place1)
            (var2 place2)
            ...
            (varN placeN))
    ...
    ...)

In this form, the placeM expression can contain references to
var1 through varM-1. This means that the evaluation of the places
is interleaved with the establishment of the variable bindings.

So, how to express:

  (setf (BIG EXPR ...) (frob b (append c (nicate (BIG EXPR ...)) d) e)) ?

  (setf a (frob b (append c (nicate a) d) e))

Like this:

  (update ((a (BIG EXPR ...)))
    (setf a (frob b (append c (nicate a) d) e)))

So here, it is understood that A is evaluated just once. It's easy
to read: ``Do this update, where all occurence of A are understood to represent
the place (BIG EXPR ...), such that (BIG EXPR ...) is evaluated only once.''

I could guess the meaning of this better than some obscure _F which
cofuses the once-only semantics with a particular /way/ of treating
a symbolic argument as a function and passing arguments to it.

I believe that it should be possible to implement UPDATE and UPDATE* with the
pieces we have in Common Lisp.

Moreover, these macros could make it easy to write custom updater
functions which avoid multiple evaluation, without having to know
DEFINE-SETF-EXPANDER, and GET-SETF-EXPANSION.

[1]> (macroexpand '(update ((a (third x)) (b (fourth y))) (push 1 a) (push a b)))
(LET (#:G3136 #:G3138 #:G3137 #:G3139 A B) (SETF #:G3136 X) (SETF #:G3138 Y)
 (SETF A (THIRD #:G3136)) (SETF B (FOURTH #:G3138))
  (MULTIPLE-VALUE-PROG1 (PROGN (PUSH 1 A) (PUSH A B)) (SETF #:G3137 A)
    (SETF #:G3139 B) (SYSTEM::%RPLACA (CDDR #:G3136) #:G3137)
      (SYSTEM::%RPLACA (CDDDR #:G3138) #:G3139)))

Implementation:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defun collect-expansion-pieces (var-place-forms)
    (loop for (var place) in var-place-forms
          collect `(,var ,@(multiple-value-list (get-setf-expansion place)))))

On Tue, 03 Nov 2009 12:49:09 +0100, Nicolas Neuss <lastn...@math.uni-karlsruhe.de> said:

  Incidentally, I just came across a word in a book which stood out to
  me in the "context" of this thread: `bumpf'... (NB: not in the sense
  of "useless printed materials" (which I didn't know before anyway)).

  ---Vassil.

Now, the user-visible variables are symbol-macrolets which expand to the
internal temporary variables used by the setf expander.

This lets us eliminate the silly hack whereby we evaluate the the getters into
our variables, and then have to setf the values to the temporaries which are
known to the store forms.

I've also rolled out the dummies and news setfs initialization into the LET,
getting rid of yet more setfs.

This is quite cleaner now.

[1]> (macroexpand '(update ((a (third x)) (b (fourth y))) (push 1 a) (push a b)))
(LET
 ((#:G3126 X) (#:G3128 Y) (#:G3127 (THIRD #:G3126)) (#:G3129 (FOURTH #:G3128)))
 (SYMBOL-MACROLET ((A #:G3127) (B #:G3129))
  (MULTIPLE-VALUE-PROG1 (PROGN (PUSH 1 A) (PUSH A B))
   (SYSTEM::%RPLACA (CDDR #:G3126) #:G3127)
   (SYSTEM::%RPLACA (CDDDR #:G3128) #:G3129)))) ;

Implementation:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defun collect-expansion-pieces (var-place-forms)
    (loop for (var place) in var-place-forms
          collect `(,var ,@(multiple-value-list (get-setf-expansion place)))))

  (defmacro update (var-place-forms &body body)
    (loop for (var dummies vals news setter getter)
          in (collect-expansion-pieces var-place-forms)
          collecting var into all-vars
          appending dummies into all-dummies
          appending vals into all-vals
          collecting (car news) into all-news
          collecting setter into all-setters
          collecting getter into all-getters
          finally
            (return `(let (,@(mapcar #'list all-dummies all-vals)
                           ,@(mapcar #'list all-news all-getters))
                       (symbol-macrolet (,@(mapcar #'list all-vars all-news))
                         (multiple-value-prog1
                           (progn ,@body)
                           ,@all-setters)))))))

UPDATE* will need a different strategy. If the symbol macro strategy is
to be retained, it will require nesting individual one-symbol symbol-macrolets
among one-symbol lets.

It occurs to me, though, that we can do the symbol-macrolets the other way!
That is to say, the gensyms returned by the GET-SETF-EXPANSION can be
installed as symbol macrolets which route to the user's variables.
Then we can generate a normal LET* to establish the user variables
directly from the getter forms. The store form from the GET-SETF-EXPANSION
will be fooled by our symbol macrolets into sucking the values directly
out of our variables. Ha!

I think I posted an implementation a few months ago to comp.lang.lisp.