Hi,
Alexandria seems to contain a lot of modify macro definitions. Which is no wonder, as those are quite practical: They're concise, and simultaneously guarantee that their arguments are only evaluated once.
Inspired from CL.el in Emacs, I grew quite fond of CALLF which is a generalized modify macro, or if you look from the right angle, an anonymous modify macro facility.
Instead of having to globally define modify macros each time you want one for a certain function, you simply use CALLF instead:
(callf #'append place l1 l2 l3 ...) == (appendf place l1 l2 l3)
(callf #'coerce place 'foo) == (coercef place 'foo)
and so on.
CALLF is actually just an abbreviation for the even more general macro CALLF-N:
(callf-n n function &rest args)
which takes the Nth argument to be the place. I.e.
(callf #'f place x y z) == (callf-n 1 #'f place x y z)
This is important if you want to use things like REMOVE or DELETE where the place is the second argument. I.e. something almost equivalent to Erik Naggum's DROP could be defined like:
(defmacro drop (object place &rest keys &key key test test-not) "Drop a particular OBJECT from list in PLACE. (Intended as counterpart to PUSH.)" (declare (ignore key test test-not)) `(callf2 #'delete ,object ,place :count 1 ,@keys))
where CALLF2 is equivalent to (CALLF-N 2); CALLF and CALLF2 are abbreviations for the most common cases, so they're specially provided.
As you can see, these macro also aid macro programming because they relieve you from having to mess with GET-SETF-EXPANSION &c.
I place the implementation below into the public domain to be included into the Alexandria library.
Notice that the implementation uses another utility BREAKUP which (together with its sibling BREAKUP-IF) should also be included into Alexandria.
-T.
(defun breakup (n list) "Breaks LIST into two pieces at position N where the (NTH n) element will become the first element of the second piece. Both pieces are returned in a list.
If N < 0, treat N as if 0.
If N >= (length LIST), return NIL as second piece.
Examples:
(breakup 0 '(0 1 2 3 4)) => (NIL (0 1 2 3 4)) (breakup 2 '(0 1 2 3 4)) => ((0 1) (2 3 4)) (breakup 9 '(0 1 2 3 4)) => ((0 1 2 3 4) NIL) " (let ((front nil)) (dotimes (i n) (when (null list) (return)) (push (car list) front) (setf list (cdr list))) (list (nreverse front) list)))
(defun breakup-if (predicate list) "Breaks LIST into two pieces at the first element of which PREDICATE returns T.
Examples:
(breakup-if #'oddp '(2 4 6 7 8 10)) => ((2 4 6) (7 8 19)) (breakup-if #'evenp '(2 4 6 7 8 10)) => (NIL (2 4 6 7 8 10)) " (loop with tail = nil for (x . rest) on list if (not (funcall predicate x)) collect x into front else do (setq tail (cons x rest)) (loop-finish) finally (return (list front tail))))
(defmacro callf-n (n function &rest args &environment env) "CALLF-N represents an anonymous modify macro facility.
The Nth argument (starting from 1) of ARGS is considered to be a `place'. This place is set to `(FUNCTION arg1 ... arg{N-1} place arg{N+1} ...)'.
Examples:
(appendf place l1 l2 ...) == (callf-n 1 #'append place l1 l2 ...)
(progn (defvar *foo* (list 1 2 (list 3 4 4 4 5) 6 7)) (callf-n 2 #'remove 4 (third *foo*)) *foo*) ==> (1 2 (3 5) 6 7) " (destructuring-bind ((&rest frontargs) (place &rest tailargs)) (breakup (1- n) args) (multiple-value-bind (gvars vals gstorevars setter getter) (get-setf-expansion place env) (when (second gstorevars) (error "CALLF does not support setting multiple values via the (VALUES ...) place.")) (let ((gstorevar (first gstorevars))) `(let ,(mapcar #'list gvars vals) (let ((,gstorevar (funcall ,function ,@frontargs ,getter ,@tailargs))) ,setter) )))))
(defmacro callf (function &rest args) "Abbreviation for (CALLF-N 1 FUNCTION args..)." `(callf-n 1 ,function ,@args))
(defmacro callf2 (function &rest args) "Abbreviation for (CALLF-N 2 FUNCTION args..)." `(callf-n 2 ,function ,@args))