j14i/cl-macros huggingface dataset:
Define a macro that eliminates this repetitive pattern:
(defgenerator flatten (list) (when list (cond ((atom list) (yield list)) (t (yield-all (flatten (car list))) (yield-all (flatten (cdr list)))))))

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 flatten (list) nil (with-yield (when list (cond ((atom list) (yield list)) (t (yield-all (flatten (car list))) (yield-all (flatten (cdr list))))))))
You are a Common Lisp macro expert. Given this code pattern:
(defmacro* nil
    (progn))

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

Macro definition:
(defmacro DEFMACRO* ...)

Macroexpansion:
(defmacro nil (progn) `(with-yield))
Generate a defmacro form that transforms code like this:
(sum-of nil)

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

Macro definition:
(defmacro SUM-OF ...)

Macroexpansion:
(lc (nil) sum)
Define a macro that eliminates this repetitive pattern:
(define-find-c-readtable-name-methods c-reader-level-2 2)

Issue: Macro call that should be transformed by define-find-c-readtable-name-methods

Macro definition:
(defmacro define-find-c-readtable-name-methods (base-readtable-name level)
  (check-type base-readtable-name symbol)
  (check-type level integer)
  (loop with case-modes = '(nil :upcase :downcase :preserve :invert)
        for mode in case-modes
        as name = (format-symbol :with-c-syntax.core "~A~@[-~A~]"
                                 base-readtable-name mode)
        collect `(defmethod find-c-readtable-name
                     ((level (eql ,level)) (readtable-case (eql ,mode)))
                   ',name)
          into bodies
        finally
           (return `(progn ,@bodies))))

Macroexpansion:
(progn (defmethod find-c-readtable-name ((level (eql 2)) (readtable-case (eql nil))) (quote c-reader-level-2)) (defmethod find-c-readtable-name ((level (eql 2)) (readtable-case (eql :upcase))) (quote c-reader-level-2-upcase)) (defmethod find-c-readtable-name ((level (eql 2)) (readtable-case (eql :downcase))) (quote c-reader-level-2-downcase)) (defmethod find-c-readtable-name ((level (eql 2)) (readtable-case (eql :preserve))) (quote c-reader-level-2-preserve)) (defmethod find-c-readtable-name ((level (eql 2)) (readtable-case (eql :invert))) (quote c-reader-level-2-invert)))
You are a Common Lisp macro expert. Given this code pattern:
(do-namespace 'some-name)

Write a macro that addresses: Macro call that should be transformed by DO-NAMESPACE

Macro definition:
(defmacro DO-NAMESPACE ...)

Macroexpansion:
(bind ((#:namespace127 (ensure-namespace 'quote)))
  (with-lock-held-on-namespace #:namespace127
    (with-hash-table-iterator (#:iterator128 (entries-of #:namespace127))
      (loop
       (bind (((:values #:has-more?129 some-name nil) (#:iterator128)))
         (declare (ignore))
         (unless #:has-more?129 (return nil)))))))
You are a Common Lisp macro expert. Given this code pattern:
(orf *log-manager* (make-instance 'log-manager))

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

Macro definition:
(defmacro orf (location form &environment env)
  (multiple-value-bind (vars values new setter getter)
      (get-setf-expansion location env)
    (when (cdr new)
      (error "Can't work with setf-expansion for ~s - ~d values from setter ~s"
             location (length new) new))
    (let ((current (car new)))
      `(let* (,@(mapcar 'list vars values)
              (,current ,getter))
         (or ,current
             (progn (setf ,current ,form)
               ,setter))))))

Macroexpansion:
(let* ((#:new128 *log-manager*)) (or #:new128 (progn (setf #:new128 (make-instance (quote log-manager))) (setq *log-manager* #:new128))))
Write a Common Lisp macro to handle this code pattern:
(defpackage nil (progn))

Problem: Macro call that should be transformed by DEFPACKAGE

Macro definition:
(defmacro DEFPACKAGE ...)

Macroexpansion:
(prog1
    (common-lisp:defpackage nil
      (progn)))
Create a Common Lisp macro for the following transformation. Before code:
(the-part nil :key nil)

What needs to change: Macro call that should be transformed by THE-PART

Macro definition:
(defmacro THE-PART ...)

Macroexpansion:
(send part nil :key nil)
Write a Common Lisp macro to handle this code pattern:
(with-preprocessor-state-slots (state) (warn 'with-c-syntax-style-warning :message (format nil "pragma '~A ~{~A~^ ~}' was ignored." first-token (remove-whitespace-marker directive-token-list))))

Problem: Macro call that should be transformed by with-preprocessor-state-slots

Macro definition:
(defmacro with-preprocessor-state-slots ((state) &body body)
  `(with-accessors ((file-pathname pp-state-file-pathname)
                    (token-list pp-state-token-list)
                    (result-list pp-state-result-list)
                    (line-number pp-state-line-number)
                    (tokens-in-line pp-state-tokens-in-line)
                    (macro-alist pp-state-macro-alist)
                    (if-section-stack pp-state-if-section-stack)
                    (if-section-skip-reason pp-state-if-section-skip-reason)
                    (include-stack pp-state-include-stack))
       ,state
     ,@body))

Macroexpansion:
(with-accessors ((file-pathname pp-state-file-pathname) (token-list pp-state-token-list) (result-list pp-state-result-list) (line-number pp-state-line-number) (tokens-in-line pp-state-tokens-in-line) (macro-alist pp-state-macro-alist) (if-section-stack pp-state-if-section-stack) (if-section-skip-reason pp-state-if-section-skip-reason) (include-stack pp-state-include-stack)) state (warn (quote with-c-syntax-style-warning) :message (format nil "pragma '~A ~{~A~^ ~}' was ignored." first-token (remove-whitespace-marker directive-token-list))))
You are a Common Lisp macro expert. Given this code pattern:
(with-builder 'some-name)

Write a macro that addresses: Macro call that should be transformed by WITH-BUILDER

Macro definition:
(defmacro WITH-BUILDER ...)

Macroexpansion:
(flet ((with-builder-thunk (quote)
         ))
  (declare (dynamic-extent (function with-builder-thunk)))
  (call-with-builder some-name #'with-builder-thunk))
Create a Common Lisp macro for the following transformation. Before code:
(with-active-layers nil
  (progn))

What needs to change: Macro call that should be transformed by WITH-ACTIVE-LAYERS

Macro definition:
(defmacro WITH-ACTIVE-LAYERS ...)

Macroexpansion:
(progn (progn))
Create a Common Lisp macro for the following transformation. Before code:
(alist-bind (name id) form (let ((size (list :bit-size (aval :bit-size form) :bit-alignment (aval :bit-alignment form))) (symbol-type (ecase type (:struct :cstruct) (:union :cunion)))) (if (anonymous-p form) (list* nil :id id size) (let ((sym (foreign-type-symbol name symbol-type *package*))) (pushnew `(,type (,sym)) *foreign-record-list* :test #'equal) (list* sym size)))))

What needs to change: Macro call that should be transformed by alist-bind

Macro definition:
(defmacro alist-bind ((&rest vars) alist &body body)
  "Inefficient but doesn't really matter here"
  (once-only (alist)
    `(let (,@(mapcar (lambda (x)
                       (if (consp x)
                           `(,(car x) (aval ,(cadr x) ,alist))
                           `(,x (aval ,(make-keyword x) ,alist))))
                     vars))
       ,@body)))

Macroexpansion:
(let ((#:alist238 form)) (let ((name (aval :name #:alist238)) (id (aval :id #:alist238))) (let ((size (list :bit-size (aval :bit-size form) :bit-alignment (aval :bit-alignment form))) (symbol-type (ecase type (:struct :cstruct) (:union :cunion)))) (if (anonymous-p form) (list* nil :id id size) (let ((sym (foreign-type-symbol name symbol-type *package*))) (pushnew (sb-int:quasiquote (#S(sb-impl::comma :expr type :kind 0) (#S(sb-impl::comma :expr sym :kind 0)))) *foreign-record-list* :test (function equal)) (list* sym size))))))
Define a macro that eliminates this repetitive pattern:
(defsyntax 'some-name)

Issue: Macro call that should be transformed by DEFSYNTAX

Macro definition:
(defmacro defsyntax (name &body options)
  `(progn
     (setf (get ',name :options) ',options)
     (defvar ,name (defreadtable ,name ,@options))))

Macroexpansion:
(progn
 (setf (get ''some-name :options) 'nil)
 (defvar 'some-name (defreadtable 'some-name)))
Create a Common Lisp macro for the following transformation. Before code:
(flet* nil)

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

Macro definition:
(defmacro FLET* ...)

Macroexpansion:
(flet nil)
Define a macro that eliminates this repetitive pattern:
(ematch0 pattern ((list* 'guard1 symbol? test more-patterns) (restart-case (let ((symopts (preprocess-symopts symbol? pattern))) (let ((*lexvars* (cons symopts *lexvars*))) (list* 'guard1 symopts test (%correct-more-patterns more-patterns)))) (repair-pattern (pattern) (correct-pattern pattern)))) ((list* 'or1 subpatterns) (let ((subpatterns (mapcar #'correct-pattern subpatterns))) (let ((all-vars (reduce #'union* subpatterns :key #'variables))) `(or1 ,@(mapcar (lambda (sp) (let* ((vars (variables sp)) (missing (set-difference all-vars vars :key #'car))) (if *or-pattern-allow-unshared-variables* (correct-pattern (bind-missing-vars-with-nil sp missing)) (restart-case (progn (assert (null missing) nil 'or1-pattern-inconsistency :pattern pattern :conflicts (list all-vars vars)) sp) (repair-pattern (sp) sp))))) subpatterns))))))

Issue: Macro call that should be transformed by ematch0

Macro definition:
(defmacro ematch0 (what &body clauses)
  `(match0 ,what
     ,@clauses
     (_ (error "level0 match error!"))))

Macroexpansion:
(match0 pattern ((list* (quote guard1) symbol? test more-patterns) (restart-case (let ((symopts (preprocess-symopts symbol? pattern))) (let ((*lexvars* (cons symopts *lexvars*))) (list* (quote guard1) symopts test (%correct-more-patterns more-patterns)))) (repair-pattern (pattern) (correct-pattern pattern)))) ((list* (quote or1) subpatterns) (let ((subpatterns (mapcar (function correct-pattern) subpatterns))) (let ((all-vars (reduce (function union*) subpatterns :key (function variables)))) (sb-int:quasiquote (or1 #S(sb-impl::comma :expr (mapcar (lambda (sp) (let* ((vars (variables sp)) (missing (set-difference all-vars vars :key (function car)))) (if *or-pattern-allow-unshared-variables* (correct-pattern (bind-missing-vars-with-nil sp missing)) (restart-case (progn (assert (null missing) nil (quote or1-pattern-inconsistency) :pattern pattern :conflicts (list all-vars vars)) sp) (repair-pattern (sp) sp))))) subpatterns) :kind 2)))))) (_ (error "level0 match error!")))
Create a Common Lisp macro for the following transformation. Before code:
(define EXIT_SUCCESS 0)

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

Macro definition:
(defmacro define (name value &rest docstring)
  "Like a #define but also visible to Lisp code."
  `(progn
     (eval-when (:compile-toplevel :load-toplevel :execute)
       (defvar ,(pp-defines *package*) (make-hash-table))
       (setf (gethash ',name ,(pp-defines *package*)) ,(prin1-to-string value)))
     (defparameter ,name ,value ,@docstring)))

Macroexpansion:
(progn (eval-when (:compile-toplevel :load-toplevel :execute) (defvar *preprocessor-defines* (make-hash-table)) (setf (gethash (quote exit_success) *preprocessor-defines*) #A((1) base-char . "0"))) (defparameter exit_success 0))
Define a macro that eliminates this repetitive pattern:
(with-yield-binds (format nil "~{~A~^ ~}" (mapcar #'yield (sql-expression-list-elements list))))

Issue: 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 "~{~A~^ ~}" (mapcar (function yield) (sql-expression-list-elements list)))) (loop for bind in (reverse *bind-values*) append bind)))
Generate a defmacro form that transforms code like this:
(define-script-symbol-macro nil
  (progn))

Pattern to recognize: Macro call that should be transformed by DEFINE-SCRIPT-SYMBOL-MACRO

Macro definition:
(defmacro DEFINE-SCRIPT-SYMBOL-MACRO ...)

Macroexpansion:
(define-ps-symbol-macro nil (progn))
Generate a defmacro form that transforms code like this:
(if-generator (g generator) (cons g nil) (cons (car g) nil))

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

Macro definition:
(defmacro if-generator ((var gen) true-clause &optional false-clause)
  "Pulls a single iteration out of gen. If a single var is specified, it places all the values from the iteration in a list under var. If var is a list, destructures values into the vars in the list. If the generator has stopped, evaluates false-clause, otherwise evaluates true-clause."
  `(,@(if (listp var)
	 `(multiple-value-bind ,var
	      (funcall ,gen))
	 `(let ((,var (multiple-value-list (funcall ,gen))))))
      (if (eq 'generator-stop
	      ,(if (listp var)
		   (car var)
		   `(car ,var)))
	  ,false-clause
	  ,true-clause)))

Macroexpansion:
(let ((g (multiple-value-list (funcall generator)))) (if (eq (quote generator-stop) (car g)) (cons (car g) nil) (cons g nil)))
Create a Common Lisp macro for the following transformation. Before code:
(signal-reader-error "String ended after \\c")

What needs to change: Macro call that should be transformed by signal-reader-error

Macro definition:
(defmacro signal-reader-error (format-control &rest format-arguments)
  "Like ERROR but signals a SIMPLE-READER-ERROR for the stream
*STREAM*."
  `(error 'simple-reader-error
          :stream *stream*
          :format-control ,format-control
          :format-arguments (list ,@format-arguments)))

Macroexpansion:
(error (quote simple-reader-error) :stream *stream* :format-control "String ended after \\c" :format-arguments (list))
Define a macro that eliminates this repetitive pattern:
(define-simple-error-for autowrap-continuable-error)

Issue: Macro call that should be transformed by define-simple-error-for

Macro definition:
(defmacro define-simple-error-for (base-type &key name object-initarg)
  "Define a simple error subclassing from BASE-TYPE and a corresponding
function, analogous to ERROR, but also optionally taking the object 
against which to err, and passing it to ERROR via the OBJECT-INITARG
keyword. The name of the simple error is constructed by prepending
'SIMPLE-' to BASE-TYPE.
Whether or not the error signaller will require and pass the
object is specified by OBJECT-INITARG being non-NIL."
  `(define-simple-condition-for ,base-type :object-initarg ,object-initarg :simple-condition-type simple-error :signaler error
                                ,@(when name `(:name ,name))))

Macroexpansion:
(define-simple-condition-for autowrap-continuable-error :object-initarg nil :simple-condition-type simple-error :signaler error)
Generate a defmacro form that transforms code like this:
(-> nil :key nil)

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

Macro definition:
(defmacro -> ...)

Macroexpansion:
(nil (:key nil))
Create a Common Lisp macro for the following transformation. Before code:
(when (or (not (node-slot body)) (typep (node-slot body) 'assignment-expression)) (format stream ";"))

What needs to change: 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 (or (not (node-slot body)) (typep (node-slot body) (quote assignment-expression))) (format stream ";"))
Define a macro that eliminates this repetitive pattern:
(c? (incf sens-ct) (trc nil "m-sens rule firing ~d !!!!!!!!!!!!!!" sens-ct) (* (^m-syn-factor) (f-sensitivity :sensa (3) (^m-syn-a))))

Issue: Macro call that should be transformed by c?

Macro definition:
(defmacro c? (&body body)
  `(make-c-dependent
    :code ',body
    :value-state :unevaluated
    :rule (c-lambda ,@body)))

Macroexpansion:
(make-c-dependent :code (quote ((incf sens-ct) (trc nil "m-sens rule firing ~d !!!!!!!!!!!!!!" sens-ct) (* (^m-syn-factor) (f-sensitivity :sensa (3) (^m-syn-a))))) :value-state :unevaluated :rule (c-lambda (incf sens-ct) (trc nil "m-sens rule firing ~d !!!!!!!!!!!!!!" sens-ct) (* (^m-syn-factor) (f-sensitivity :sensa (3) (^m-syn-a)))))
Define a macro that eliminates this repetitive pattern:
(defrec)

Issue: Macro call that should be transformed by DEFREC

Macro definition:
(defmacro DEFREC ...)

Macroexpansion:
nil
Create a Common Lisp macro for the following transformation. Before code:
(destructuring-match 'some-name)

What needs to change: Macro call that should be transformed by DESTRUCTURING-MATCH

Macro definition:
(defmacro DESTRUCTURING-MATCH ...)

Macroexpansion:
(let ((#:form 'some-name))
  (block #:done
    (let ((#:done
           (lambda (&rest values)
             (declare (dynamic-extent values))
             (return-from #:done (values-list values)))))
      (tagbody))))
You are a Common Lisp macro expert. Given this code pattern:
(define-alias-binding minimize minimizing)

Write a macro that addresses: Macro call that should be transformed by define-alias-binding

Macro definition:
(defmacro define-alias-binding (name referenced-binding-name)
  `(progn (setf (binding ',name) ',referenced-binding-name)
          ',name))

Macroexpansion:
(progn (setf (binding (quote minimize)) (quote minimizing)) (quote minimize))
You are a Common Lisp macro expert. Given this code pattern:
(draw scene (:path :d curvy) :fill "none" :stroke "yellow")

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

Macro definition:
(defmacro draw (scene (shape &rest params) &rest opts)
  (let ((element (gensym)))
    `(let ((,element (funcall #'make-svg-element ,shape (append (list ,@params) (list ,@opts)))))
       (add-element ,scene ,element)
       ,element)))

Macroexpansion:
(let ((#:g162 (funcall (function make-svg-element) :path (append (list :d curvy) (list :fill "none" :stroke "yellow"))))) (add-element scene #:g162) #:g162)
Generate a defmacro form that transforms code like this:
(with-env [arr 0 2])

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

Macro definition:
(defmacro with-env (&body body)
  (let ((body-value (gensym)))
    `(let (,body-value)
       (defclass foo () ((a :initform 3)))
       (defmethod get-val ((object foo) &rest slot/s) (slot-value object (car slot/s)))
       (defmethod (setf get-val) (new-value (object foo) &rest slot/s)
         (setf (slot-value object (car slot/s)) new-value))
       (defstruct bar a)
       (setq ,body-value
             (let ((str (alexandria:copy-array "abcde"))
                   (vec (alexandria:copy-array #(a b c d e)))
                   (arr (alexandria:copy-array #2A((1 2 3)
                                                   (4 5 6))))
                   (list      (copy-list '(a b c d e)))
                   (ht        (eval (read-from-string "{'a 'b 'c 'd}")))
                   (ht-eq     (eval (read-from-string "{eq \"a\" 1
                                                    \"b\" 2}")))
                   (ht-equalp (eval (read-from-string "{equalp '(1 2 3) \"a\"
                                                               '(4 5 6) \"b\"}")))
                   (assoc-list (copy-tree '((a . 1) (b . 2))))
                   (plist      (copy-list '(:a 4 :c 5)))
                   (clos-object (make-instance 'foo))
                   (struct      (make-bar :a 3)))
               (declare (ignorable str vec arr list ht ht-eq ht-equalp
                                   assoc-list plist clos-object struct))
               ,@body))
       (setf (find-class 'foo nil) nil)
       (setf (find-class 'bar nil) nil)
       ,body-value))

Macroexpansion:
(let (#:g124) (defclass foo nil ((a :initform 3))) (defmethod get-val ((object foo) &rest slot/s) (slot-value object (car slot/s))) (defmethod (setf get-val) (new-value (object foo) &rest slot/s) (setf (slot-value object (car slot/s)) new-value)) (defstruct bar a) (setq #:g124 (let ((str (alexandria:copy-array "abcde")) (vec (alexandria:copy-array #(a b c d e))) (arr (alexandria:copy-array #2A((1 2 3) (4 5 6)))) (list (copy-list (quote (a b c d e)))) (ht (eval (read-from-string "{'a 'b 'c 'd}"))) (ht-eq (eval (read-from-string "{eq \"a\" 1
                                                    \"b\" 2}"))) (ht-equalp (eval (read-from-string "{equalp '(1 2 3) \"a\"
                                                               '(4 5 6) \"b\"}"))) (assoc-list (copy-tree (quote ((a . 1) (b . 2))))) (plist (copy-list (quote (:a 4 :c 5)))) (clos-object (make-instance (quote foo))) (struct (make-bar :a 3))) (declare (ignorable str vec arr list ht ht-eq ht-equalp assoc-list plist clos-object struct)) [arr 0 2])) (setf (find-class (quote foo) nil) nil) (setf (find-class (quote bar) nil) nil) #:g124)
Create a Common Lisp macro for the following transformation. Before code:
(defclass/std unknown () ((slot :unknown :keywords)))

What needs to change: 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 :initarg :slot :initform nil :unknown :keywords)))
Generate a defmacro form that transforms code like this:
(when (node-slot step) (del-proxy step))

Pattern to recognize: 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 (node-slot step) (del-proxy step))
Generate a defmacro form that transforms code like this:
(mvlet* nil
  :key
  nil)

Pattern to recognize: Macro call that should be transformed by MVLET*

Macro definition:
(defmacro MVLET* ...)

Macroexpansion:
(progn :key nil)
Define a macro that eliminates this repetitive pattern:
(def-dynenv-var nil)

Issue: Macro call that should be transformed by DEF-DYNENV-VAR

Macro definition:
(defmacro DEF-DYNENV-VAR ...)

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defvar #:nil171)
  (setf (get 'nil 'dynenv-var) '#:nil171)
  (define-symbol-macro nil (get-dynenv-var 'nil)))
You are a Common Lisp macro expert. Given this code pattern:
(advisable-lambda nil
  :key
  nil)

Write a macro that addresses: Macro call that should be transformed by ADVISABLE-LAMBDA

Macro definition:
(defmacro ADVISABLE-LAMBDA ...)

Macroexpansion:
(make-instance 'advisable-function :main #'(lambda () :key nil) :arguments 'nil
               :dispatcher-generator
               #'(lambda (#:fobj128)
                   #'(lambda ()
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed129 (append)))
                         (apply-before #:fobj128 #:fixed129)
                         (multiple-value-prog1
                             (apply-around #:fobj128 #:fixed129)
                           (apply-after #:fobj128 #:fixed129))))))