j14i/cl-macros huggingface dataset:
Define a macro that eliminates this repetitive pattern:
(defhandler eval-when (eval-when situation &rest body) `(list ',eval-when ',situation ,@(e-list body)))

Issue: Macro call that should be transformed by defhandler

Macro definition:
(defmacro defhandler (symbol lambda-list &body body)
  (let ((syms (force-list symbol)))
    (let ((func (intern (format nil "~A~A" 'hander- (first syms)))))
      `(progn
         (defun ,func ,lambda-list
           ,@body)
         (setf
          ,@(loop for sym in syms
               collect `(gethash ',sym *form-handler*)
               collect `',func))))))

Macroexpansion:
(progn (defun hander-eval-when (eval-when situation &rest body) (sb-int:quasiquote (list (quote #S(sb-impl::comma :expr eval-when :kind 0)) (quote #S(sb-impl::comma :expr situation :kind 0)) #S(sb-impl::comma :expr (e-list body) :kind 2)))) (setf (gethash (quote eval-when) *form-handler*) (quote hander-eval-when)))
Generate a defmacro form that transforms code like this:
(with-component-testers (a b #'pathname-host) (eq a b) (components-are-member '(nil :unspecific)) (components-are-string=) (components-are-every #'string=))

Pattern to recognize: Macro call that should be transformed by with-component-testers

Macro definition:
(defmacro with-component-testers ((a b key) &body body)
  (let ((k (gensym)))
    `(let* ((,k ,key)
            (,a (funcall ,k ,a))
            (,b (funcall ,k ,b)))
       (labels ((components-are (test)
                  (and (funcall test ,a) (funcall test ,b)))
                (components-are-member (values)
                  (and (member ,a values :test #'eql)
                       (member ,b values :test #'eql)
                       (eql ,a ,b)))
                (components-are-string= ()
                  (and (stringp ,a) (stringp ,b) (string= ,a ,b)))
                (components-are-every (test)
                  (and (consp ,a)
                       (consp ,b)
                       (every test ,a ,b))))
         (declare (ignorable #'components-are #'components-are-member
                             #'components-are-string= #'components-are-every))
         (if (or ,@body)
             (values t ,a ,b)
             nil)))))

Macroexpansion:
(let* ((#:g143 (function pathname-host)) (a (funcall #:g143 a)) (b (funcall #:g143 b))) (labels ((components-are (test) (and (funcall test a) (funcall test b))) (components-are-member (values) (and (member a values :test (function eql)) (member b values :test (function eql)) (eql a b))) (components-are-string= nil (and (stringp a) (stringp b) (string= a b))) (components-are-every (test) (and (consp a) (consp b) (every test a b)))) (declare (ignorable (function components-are) (function components-are-member) (function components-are-string=) (function components-are-every))) (if (or (eq a b) (components-are-member (quote (nil :unspecific))) (components-are-string=) (components-are-every (function string=))) (values t a b) nil)))
Create a Common Lisp macro for the following transformation. Before code:
(define-class-method nil
    (progn))

What needs to change: Macro call that should be transformed by DEFINE-CLASS-METHOD

Macro definition:
(defmacro DEFINE-CLASS-METHOD ...)

Macroexpansion:
(progn
 (define-incongruent-method nil
     (progn))
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (add-class-principal-method 'nil '(progn))))
Create a Common Lisp macro for the following transformation. Before code:
(defclause counting (var) "Counts the number of iterations, starting from 0." (make-simple-iteration :var var :init 0 :step `(1+ ,var)))

What needs to change: Macro call that should be transformed by defclause

Macro definition:
(defmacro defclause (name arglist &body body)
  "Same as cl:defmacro, but additionally records <name> in *clauses* as a known clause macro."
  `(progn
     (defmacro ,name ,arglist ,@body)
     (pushnew ',name *clauses*)))

Macroexpansion:
(progn (defmacro counting (var) "Counts the number of iterations, starting from 0." (make-simple-iteration :var var :init 0 :step (sb-int:quasiquote (1+ #S(sb-impl::comma :expr var :kind 0))))) (pushnew (quote counting) *clauses*))
Write a Common Lisp macro to handle this code pattern:
(rem-arg-list-key-value! nil nil)

Problem: Macro call that should be transformed by REM-ARG-LIST-KEY-VALUE!

Macro definition:
(defmacro rem-arg-list-key-value! (ids place &key (test '#'equalper) (key '#'identity))
  `(progn
    (iter (for id in (ensure-list ,ids))
      (setf ,place (rem-arg-list-key-value id ,place :test ,test :key ,key)))
    ,place))

Macroexpansion:
(progn
 (iter
   (for id in (ensure-list nil))
   (setf nil (rem-arg-list-key-value id nil :test #'equalper :key #'identity)))
 nil)
Generate a defmacro form that transforms code like this:
(define-filtered-function nil
    nil)

Pattern to recognize: Macro call that should be transformed by DEFINE-FILTERED-FUNCTION

Macro definition:
(defmacro DEFINE-FILTERED-FUNCTION ...)

Macroexpansion:
(progn
 (defgeneric nil
     nil
   (:generic-function-class filtered-function)
   (:method-class filtered-method)
   (:method-combination filtered))
 (setf (generic-function-filters (fdefinition 'nil)) (list))
 'nil)
You are a Common Lisp macro expert. Given this code pattern:
(iterate
  nil)

Write a macro that addresses: Macro call that should be transformed by ITERATE

Macro definition:
(defmacro ITERATE ...)

Macroexpansion:
(iter
  nil)
Generate a defmacro form that transforms code like this:
(ltbdd-with-new-hash 'some-name)

Pattern to recognize: Macro call that should be transformed by LTBDD-WITH-NEW-HASH

Macro definition:
(defmacro LTBDD-WITH-NEW-HASH ...)

Macroexpansion:
(bdd-call-with-new-hash (lambda (quote some-name)) :bdd-node-type
                        '(or lisp-type-bdd-node bdd-leaf))
You are a Common Lisp macro expert. Given this code pattern:
(with-yield (do-generators ((g (some-numbers)) (:list l data :fill-value 0)) (yield (+ l g))))

Write a macro that addresses: Macro call that should be transformed by with-yield

Macro definition:
(defmacro with-yield (&body body)
  (let ((point (gensym))
        (current (gensym)))
    `(let (,point ,current)
       (with-call/cc
	 (labels ((yield (&rest values)
		    (setf ,current values)
		    (let/cc k
		      (setf ,point k))))
	   ,@body
	   (setf ,point nil)))
       (gen-lambda ()
	 (cond ((null ,point)
		'generator-stop)
	       (t
		(let ((current ,current))
		  (funcall ,point nil)
		  ;values-handler: see gen-lambda
		  (apply #'values (funcall values-handler current)))))))))

Macroexpansion:
(let (#:g147 #:g148) (with-call/cc (labels ((yield (&rest values) (setf #:g148 values) (let/cc k (setf #:g147 k)))) (do-generators ((g (some-numbers)) (:list l data :fill-value 0)) (yield (+ l g))) (setf #:g147 nil))) (gen-lambda nil (cond ((null #:g147) (quote generator-stop)) (t (let ((current #:g148)) (funcall #:g147 nil) (apply (function values) (funcall values-handler current)))))))
Create a Common Lisp macro for the following transformation. Before code:
(matrix-ecase nil)

What needs to change: Macro call that should be transformed by MATRIX-ECASE

Macro definition:
(defmacro MATRIX-ECASE ...)

Macroexpansion:
nil
Write a Common Lisp macro to handle this code pattern:
(do+ (for (x &optional (y 'y) &rest z &key k1 (k2 'k2) ((:kk k3) 'k3)) (in '((1 a) (2) (3 c :k1 a :kk b :k2 c)))) (collect (list x y z k1 k2 k3)))

Problem: Macro call that should be transformed by do+

Macro definition:
(defmacro do+ (&body body)
  "High-level, extensible iteration construct. Refer to the manual for syntax and semantics."
  `(do+/internal nil ,@body))

Macroexpansion:
(do+/internal nil (for (x &optional (y (quote y)) &rest z &key k1 (k2 (quote k2)) ((:kk k3) (quote k3))) (in (quote ((1 a) (2) (3 c :k1 a :kk b :k2 c))))) (collect (list x y z k1 k2 k3)))
You are a Common Lisp macro expert. Given this code pattern:
(rem-bops 'some-name)

Write a macro that addresses: Macro call that should be transformed by REM-BOPS

Macro definition:
(defmacro REM-BOPS ...)

Macroexpansion:
(eval-when (:load-toplevel :compile-toplevel :execute)
  (progn (save-binfix) (mapc 'rmbop '('some-name)) (assign-properties)))
Create a Common Lisp macro for the following transformation. Before code:
(define-bug problem-with-the-compiler () (target) "This shouldnt have been possible so this needs a bug report. Sorry about that~%~s" target)

What needs to change: Macro call that should be transformed by define-bug

Macro definition:
(defmacro define-bug (name (&key (error-type 'varjo-error) (prefix "Varjo Bug"))
                            (&rest args) error-string &body body)
  `(defcondition ,name (:error-type ,error-type :prefix ,prefix) ,args
       ,error-string ,@body))

Macroexpansion:
(defcondition problem-with-the-compiler (:error-type varjo-error :prefix "Varjo Bug") (target) "This shouldnt have been possible so this needs a bug report. Sorry about that~%~s" target)
Define a macro that eliminates this repetitive pattern:
(unless nil :key nil)

Issue: Macro call that should be transformed by UNLESS

Macro definition:
(defmacro UNLESS ...)

Macroexpansion:
(if nil
    nil
    (progn :key nil))
Write a Common Lisp macro to handle this code pattern:
(quasiquote-unexpand-1 'unquote-nsplicing el)

Problem: Macro call that should be transformed by quasiquote

Macro definition:
(defmacro quasiquote (x) (quasiquote-expand x))

Macroexpansion:
(quasiquote-unexpand-1 (quote unquote-nsplicing) el)
You are a Common Lisp macro expert. Given this code pattern:
(with-yield-binds (format nil "ON DUPLICATE KEY UPDATE ~{~A = ~A~^, ~}" (mapcar #'yield-arg (on-duplicate-key-update-clause-args clause))))

Write a macro that addresses: Macro call that should be transformed by with-yield-binds

Macro definition:
(defmacro with-yield-binds (&body body)
  `(let ((*bind-values* nil)
         (*use-global-bind-values* t))
     (values
      (progn ,@body)
      (loop for bind in (reverse *bind-values*)
            append bind))))

Macroexpansion:
(let ((*bind-values* nil) (*use-global-bind-values* t)) (values (progn (format nil "ON DUPLICATE KEY UPDATE ~{~A = ~A~^, ~}" (mapcar (function yield-arg) (on-duplicate-key-update-clause-args clause)))) (loop for bind in (reverse *bind-values*) append bind)))
Generate a defmacro form that transforms code like this:
(defclass/std unknown () ((slot :a :unknown keywords :without-values)))

Pattern to recognize: Macro call that should be transformed by defclass/std

Macro definition:
(defmacro defclass/std (name direct-superclasses direct-slots &rest options
                        &environment env)
  "Shortcut macro to the DEFCLASS macro.

  (defclass/std example ()
    ((slot1 slot2 slot3)))

  expands to:

  (DEFCLASS EXAMPLE ()
    ((SLOT1 :ACCESSOR SLOT1 :INITARG :SLOT1 :INITFORM NIL)
    (SLOT2 :ACCESSOR SLOT2 :INITARG :SLOT2 :INITFORM NIL)
    (SLOT3 :ACCESSOR SLOT3 :INITARG :SLOT3 :INITFORM NIL)))

  Each slot definition accepts options:

    :std 1 => changes the :initform to 1. It can be :unbound.
    :with or :with-prefix => creates accessors with the class name as prefix.

  See the README for more.

  See also `class/std' and `print-object/std'.
  "
  `(defclass ,name ,direct-superclasses
     ,(process-slots env direct-slots name)
     ,@options))

Macroexpansion:
(defclass unknown nil ((slot :accessor slot :initform nil :unknown keywords :without-values)))
You are a Common Lisp macro expert. Given this code pattern:
(pmap #'1+ #'unsigned)

Write a macro that addresses: Macro call that should be transformed by pmap

Macro definition:
(defmacro pmap (f parser)
  "Similar to `fmap', but this transforms a parser into another one, altering
its inner result if it happened to be successful."
  `(lambda (offset)
     (fmap ,f (funcall ,parser offset))))

Macroexpansion:
(lambda (offset) (fmap (function 1+) (funcall (function unsigned) offset)))
Define a macro that eliminates this repetitive pattern:
(with-reader-syntax (get-val array hash-table) (with-output-to-string (*error-output*) (is (char= #\f (er "(with-env (setp #\\f [str 0]))"))) (is (eq 'f (er "(with-env (setp 'f [vec 0]))"))) (is (= 4 (er "(with-env (setp 4 [arr 0 2]))"))) (is (eq 'f (er "(with-env (setp 'f [list 3]))"))) (is (eq 'f (er "(with-env (setp 'f [ht 'a]))"))) (is (= 2 (er "(with-env (setp 2 [assoc-list 'a]))"))) (is (eq 3 (er "(with-env (setp 3 [assoc-list 'c]))"))) (is (= 2 (er "(with-env (setp 2 [plist :c]))"))) (is (eq 3 (er "(with-env (setp 3 [plist :e]))"))) (is (eq 5 (er "(with-env (setp 5 [clos-object 'a]))"))) (is (eq 7 (er "(with-env (setp 7 [struct 'a]))")))))

Issue: Macro call that should be transformed by with-reader-syntax

Macro definition:
(defmacro with-reader-syntax (reader-macro-identifiers &body body)
  "This macro is only made for use by read-and-eval functionality,
and rather directed towards tests than users. So, do not export."
  (let ((identifiers (loop :for identifier :in reader-macro-identifiers
                           :collect `(quote ,identifier))))
    `(let ((*array-function*         'make-t-array-from-initial-contents)
           (*hash-table-function*    'alexandria:plist-hash-table)
           (*get-val-function*       'get-val)
           (*get-val-array-function* 'cl:aref)
           (*set-function*           'cl:remove-duplicates)
           (*alists-are-lists*       nil)
           (*plists-are-lists*       nil)
           (*readtable*             (%enable-reader-syntax *readtable* ,@identifiers)))
       ,@body)))

Macroexpansion:
(let ((*array-function* (quote make-t-array-from-initial-contents)) (*hash-table-function* (quote alexandria:plist-hash-table)) (*get-val-function* (quote get-val)) (*get-val-array-function* (quote aref)) (*set-function* (quote remove-duplicates)) (*alists-are-lists* nil) (*plists-are-lists* nil) (*readtable* (%enable-reader-syntax *readtable* (quote get-val) (quote array) (quote hash-table)))) (with-output-to-string (*error-output*) (is (char= #\LATIN_SMALL_LETTER_F (er "(with-env (setp #\\f [str 0]))"))) (is (eq (quote f) (er "(with-env (setp 'f [vec 0]))"))) (is (= 4 (er "(with-env (setp 4 [arr 0 2]))"))) (is (eq (quote f) (er "(with-env (setp 'f [list 3]))"))) (is (eq (quote f) (er "(with-env (setp 'f [ht 'a]))"))) (is (= 2 (er "(with-env (setp 2 [assoc-list 'a]))"))) (is (eq 3 (er "(with-env (setp 3 [assoc-list 'c]))"))) (is (= 2 (er "(with-env (setp 2 [plist :c]))"))) (is (eq 3 (er "(with-env (setp 3 [plist :e]))"))) (is (eq 5 (er "(with-env (setp 5 [clos-object 'a]))"))) (is (eq 7 (er "(with-env (setp 7 [struct 'a]))")))))
Write a Common Lisp macro to handle this code pattern:
(cond->> 'some-name)

Problem: Macro call that should be transformed by COND->>

Macro definition:
(defmacro COND->> ...)

Macroexpansion:
(let* ((#:g137 'some-name))
  #:g137)
Generate a defmacro form that transforms code like this:
(with-standard-definer-options nil
  nil)

Pattern to recognize: Macro call that should be transformed by WITH-STANDARD-DEFINER-OPTIONS

Macro definition:
(defmacro WITH-STANDARD-DEFINER-OPTIONS ...)

Macroexpansion:
`(progn
  ,@(when (getf -options- :export)
      `((eval-when (:compile-toplevel :load-toplevel :execute)
          (export ',nil))))
  ,nil)
Generate a defmacro form that transforms code like this:
(defstore example (object &key &allow-other-keys))

Pattern to recognize: Macro call that should be transformed by defstore

Macro definition:
(defmacro defstore (store-name store-lambda-list &body body &environment env)
  (let* ((store-class-name (second (find :store-class body :key #'first)))
         (store-class (etypecase store-class-name
                        (null (find-class 'standard-store))
                        (symbol (find-class store-class-name))))
         (form (apply #'defstore-using-class store-class store-name store-lambda-list
                      :environment env
                      (mapcan #'(lambda (item)
                                  (cond ((eql (first item) :store-class)
                                         `(:store-class ',store-class-name))
                                        ((and (member (first item) '(:documentation :specialization-class)))
                                         (if (= 2 (length item))
                                             item
                                             (error "Invalid store definition option: ~W." item)))
                                        (t
                                         (list (first item) (rest item)))))
                              body))))
    `(eval-when (:compile-toplevel :load-toplevel :execute)
       ,form)))

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute) (progn (ensure-store (quote example) (quote (object &key &allow-other-keys)))))
You are a Common Lisp macro expert. Given this code pattern:
(is #\a #\a)

Write a macro that addresses: Macro call that should be transformed by is

Macro definition:
(defmacro is (got expected &rest args)
  (with-gensyms (duration result new-args desc)
    (once-only (expected)
      `(let* ((,new-args (list ,@args))
              (,desc (parse-description-and-test ,new-args)))
         (with-catching-errors (:description ,desc :expected ,expected)
           (with-duration ((,duration ,result) ,got)
             (test ,result ,expected ,new-args
                   :duration ,duration)))))))

Macroexpansion:
(let ((#:expected166 #\LATIN_SMALL_LETTER_A)) (let* ((#:new-args164 (list)) (#:desc165 (parse-description-and-test #:new-args164))) (with-catching-errors (:description #:desc165 :expected #:expected166) (with-duration ((#:duration162 #:result163) #\LATIN_SMALL_LETTER_A) (test #:result163 #:expected166 #:new-args164 :duration #:duration162)))))
Define a macro that eliminates this repetitive pattern:
(defgenerator dropwhile (predicate generator) "Goes through generator, dropping the items until the predicate fails, then emits the rest of the source generator's items. Eg: (dropwhile (lambda (x) (< x 5)) (list->generator '(1 4 6 4 1))) -> 6 4 1" (do-generator (item generator) (unless (funcall predicate item) (yield item) (return))) (yield-all generator))

Issue: Macro call that should be transformed by defgenerator

Macro definition:
(defmacro defgenerator (name arguments &body body)
  (multiple-value-bind (remaining-forms declarations doc-string)
      (alexandria:parse-body body :documentation t)
    `(defun ,name ,arguments
       ,doc-string
       ,@declarations
       (with-yield
	 ,@remaining-forms))))

Macroexpansion:
(defun dropwhile (predicate generator) "Goes through generator, dropping the items until the predicate fails, then emits the rest of the source generator's items. Eg: (dropwhile (lambda (x) (< x 5)) (list->generator '(1 4 6 4 1))) -> 6 4 1" (with-yield (do-generator (item generator) (unless (funcall predicate item) (yield item) (return))) (yield-all generator)))
Generate a defmacro form that transforms code like this:
(-> :tag-3 (text) (setf result text) (mt:open-latch latch))

Pattern to recognize: Macro call that should be transformed by ->

Macro definition:
(defmacro -> (invariant &body args)
  "See flow:atomically"
  `(atomically ,invariant ,@args))

Macroexpansion:
(atomically :tag-3 (text) (setf result text) (cl-muth:open-latch latch))
Define a macro that eliminates this repetitive pattern:
(def-launched-iter nil
    (progn))

Issue: Macro call that should be transformed by DEF-LAUNCHED-ITER

Macro definition:
(defmacro DEF-LAUNCHED-ITER ...)

Macroexpansion:
(defun nil (progn)
  (let ((it (make-instance 'iterator :coro (lambda-coro))))
    (inext-or-error it)
    it))
You are a Common Lisp macro expert. Given this code pattern:
(when (and (>= (length operatorXX) 8) (string-equal "operator" operatorXX :start2 0 :end2 8)) (when (not (gethash operatorXX name-map))) (setf (gethash operatorXX name-map) check-name))

Write a macro that addresses: Macro call that should be transformed by when

Macro definition:
(defmacro when (test &body forms)
  `(if ,test
	   ,(cl:if (cadr forms)
			   `(progn ,@forms)
			   (car forms))))

Macroexpansion:
(if (and (>= (length operatorxx) 8) (string-equal "operator" operatorxx :start2 0 :end2 8)) (progn (when (not (gethash operatorxx name-map))) (setf (gethash operatorxx name-map) check-name)))
Generate a defmacro form that transforms code like this:
(with-wcs-math-error-handling (ret (log x)) (check-wcs-math-result))

Pattern to recognize: Macro call that should be transformed by with-wcs-math-error-handling

Macro definition:
(defmacro with-wcs-math-error-handling
    ((var-or-var-list
      (function x &optional (y nil y-supplied-p))
      &rest keyargs
      &key underflow-value)
     &body body)
  (declare (ignorable underflow-value))
  (let ((x_ (gensym)) (y_ (gensym)) (args_ (gensym))
        (var-list (ensure-list var-or-var-list)))
    `(let* ((,x_ ,x)
            (,y_ ,y)
            (,args_ (list ,x_ ,@(if y-supplied-p `(,y_)))))
       (declare (ignorable ,y_)
                (type list ,args_)
                (dynamic-extent ,args_))
       (catch 'return-from-with-wcs-math-error-handling
         (multiple-value-bind ,var-list
             (call-with-wcs-math-error-handler ',function ,args_
                                               ,@keyargs)
           (flet ((check-wcs-math-result
                      (&optional (ret ,(first var-list))
                                 (arg-list ,args_))
                    (check-wcs-math-result ret arg-list)))
             ,@body))))))

Macroexpansion:
(let* ((#:g221 x) (#:g222 nil) (#:g223 (list #:g221))) (declare (ignorable #:g222) (type list #:g223) (dynamic-extent #:g223)) (catch (quote return-from-with-wcs-math-error-handling) (multiple-value-bind (ret) (call-with-wcs-math-error-handler (quote log) #:g223) (flet ((check-wcs-math-result (&optional (ret ret) (arg-list #:g223)) (check-wcs-math-result ret arg-list))) (check-wcs-math-result)))))
Create a Common Lisp macro for the following transformation. Before code:
(do-iter-values ((item it)) (setf result (funcall f (funcall key item) result)))

What needs to change: Macro call that should be transformed by do-iter-values

Macro definition:
(defmacro do-iter-values ((&rest iters) &body forms)
  "Iterate over the remaining elements of a sequence pointed to by static iterators.

   Evaluate FORMS at each iteration, for each remaining element, until
   one of the iterators reaches the end of the sequence.

   NOTE: May only be used inside a WITH-ITERATORS form.

   ITERS:

     List of bindings. Each element is of the form (PATTERN ITER),
     interpreted as if to WITH-ITER-VALUE, where PATTERN is a binding
     pattern, for the binding to the sequence element value, and ITER
     is a static iterator identifier symbol, introduced in a parent
     WITH-ITERATORS form.

   FORMS

     List of forms evaluated for each remaining element in the
     sequences pointed to by the static iterators.

     At each evaluation the next element of each sequence, pointed by
     each ITER in ITERS, is bound to the variable(s) specified by the
     corresponding PATTERN. After which the iterators are advanced to
     the next elements.

   If one of the iterators has reached the end of its sequence, a
   non-local jump outside the enclosing WITH-ITERATORS form is
   performed, i.e. any forms following this form, within the enclosing
   WITH-ITERATORS form, will not be evaluated."

  (with-gensyms (start)
    `(tagbody
        ,start
        (with-iter-values ,iters ,@forms)
        (go ,start))))

Macroexpansion:
(tagbody #:start171 (with-iter-values ((item it)) (setf result (funcall f (funcall key item) result))) (go #:start171))
Generate a defmacro form that transforms code like this:
(disable-reader-syntax)

Pattern to recognize: Macro call that should be transformed by DISABLE-READER-SYNTAX

Macro definition:
(defmacro DISABLE-READER-SYNTAX ...)

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (setq *readtable*
          (if *previous-readtables*
              (pop *previous-readtables*)
              (copy-readtable nil))))
Generate a defmacro form that transforms code like this:
(augment *final* final)

Pattern to recognize: Macro call that should be transformed by augment

Macro definition:
(defmacro augment (var stuff)
  `(setf ,var (nconc ,var ,stuff)))

Macroexpansion:
(setf *final* (nconc *final* final))