j14i/cl-macros huggingface dataset:
Create a Common Lisp macro for the following transformation. Before code:
(defhandler declare (declare &rest body) `(list ',declare ,@(mapcar (lambda (f) `',f) body)))

What needs to change: 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-declare (declare &rest body) (sb-int:quasiquote (list (quote #S(sb-impl::comma :expr declare :kind 0)) #S(sb-impl::comma :expr (mapcar (lambda (f) (sb-int:quasiquote (quote #S(sb-impl::comma :expr f :kind 0)))) body) :kind 2)))) (setf (gethash (quote declare) *form-handler*) (quote hander-declare)))
Create a Common Lisp macro for the following transformation. Before code:
(defalias path:-e (pathname) cl-fad:file-exists-p)

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

Macro definition:
(defmacro defalias (name args realname)
  `(progn
     (defun ,name ,args
       ,(if (eql '&rest (first args))
            `(apply #',realname ,(second args))
            `(,realname ,@args)))
     (define-compiler-macro ,name (&rest args)
       (list* ',realname args))))

Macroexpansion:
(progn (defun path:-e (pathname) (file-exists-p pathname)) (define-compiler-macro path:-e (&rest args) (list* (quote file-exists-p) args)))
You are a Common Lisp macro expert. Given this code pattern:
(define-custom-var (:end-of-string *end-of-string-handler*))

Write a macro that addresses: Macro call that should be transformed by define-custom-var

Macro definition:
(defmacro define-custom-var ((key name) &rest other-args)
  `(eval-when (:compile-toplevel :load-toplevel :execute)
     (progn (pushnew '(,name . ,key) *custom-vars* :test #'equal)
            (defvar ,name ,@other-args))))

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute) (progn (pushnew (quote (*end-of-string-handler* . :end-of-string)) *custom-vars* :test (function equal)) (defvar *end-of-string-handler*)))
You are a Common Lisp macro expert. Given this code pattern:
(defhandler progv (progv symbols values &rest body) `(list ',progv (list ,@(e-list symbols)) (list ,@(e-list values)) ,@(e-list body)))

Write a macro that addresses: 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-progv (progv symbols values &rest body) (sb-int:quasiquote (list (quote #S(sb-impl::comma :expr progv :kind 0)) (list #S(sb-impl::comma :expr (e-list symbols) :kind 2)) (list #S(sb-impl::comma :expr (e-list values) :kind 2)) #S(sb-impl::comma :expr (e-list body) :kind 2)))) (setf (gethash (quote progv) *form-handler*) (quote hander-progv)))
You are a Common Lisp macro expert. Given this code pattern:
(advisable-lambda 'some-name)

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 (quote some-name))
               :arguments ''some-name :dispatcher-generator
               #'(lambda (#:fobj130)
                   #'(lambda (quote some-name)
                       #A((29) base-char . "Advisable function dispatcher")
                       (let ((#:fixed131
                              (append (list quote) (list some-name))))
                         (apply-before #:fobj130 #:fixed131)
                         (multiple-value-prog1
                             (apply-around #:fobj130 #:fixed131)
                           (apply-after #:fobj130 #:fixed131))))))
You are a Common Lisp macro expert. Given this code pattern:
(deferror "42P04" duplicate-database syntax-error-or-access-violation)

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

Macro definition:
(defmacro deferror (code typename &optional (superclass 'database-error))
  `(progn (define-condition ,typename (,superclass) ())
          (setf (gethash ,code *error-table*) ',typename)))

Macroexpansion:
(progn (define-condition duplicate-database (syntax-error-or-access-violation) nil) (setf (gethash "42P04" *error-table*) (quote duplicate-database)))
Define a macro that eliminates this repetitive pattern:
(when (eql (top-sign) 'skip-first) (pop-sign))

Issue: 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 (eql (top-sign) (quote skip-first)) (pop-sign))
Create a Common Lisp macro for the following transformation. Before code:
(with-html-string (:div :class "status col-xs-2 col-md-1" (:span :class "text-success" (:a :href "https://en.wikipedia.org/wiki/List_of_HTTP_status_codes#200" 200))))

What needs to change: Macro call that should be transformed by with-html

Macro definition:
(defmacro with-html (&body body &environment env)
  "Interpret BODY as HTML. Consult README.txt for the syntax."
  `(let ((*html* (ensure-html-stream *html*)))
     ,(if (and (null (cdr body)) (atom (car body)))
          (car body)
          `(progn ,@(parse-html body env)))))

Macroexpansion:
(with-output-to-string (*html*) (with-html (:div :class "status col-xs-2 col-md-1" (:span :class "text-success" (:a :href "https://en.wikipedia.org/wiki/List_of_HTTP_status_codes#200" 200)))))
Generate a defmacro form that transforms code like this:
(c? (incf plus-ct) (trc nil "m-plus rule firing!!!!!!!!!!!!!!" plus-ct) (f-plusp :syna-2 (- 2 (^m-syn-a))))

Pattern to recognize: 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 plus-ct) (trc nil "m-plus rule firing!!!!!!!!!!!!!!" plus-ct) (f-plusp :syna-2 (- 2 (^m-syn-a))))) :value-state :unevaluated :rule (c-lambda (incf plus-ct) (trc nil "m-plus rule firing!!!!!!!!!!!!!!" plus-ct) (f-plusp :syna-2 (- 2 (^m-syn-a)))))
Generate a defmacro form that transforms code like this:
(alet (1+ 1) it (1+ it))

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

Macro definition:
(defmacro alet (form &body body)
  "Binds the FORM to IT (via LET) in the scope of the BODY."
  `(anaphoric ignore-first ,form (progn ,@body)))

Macroexpansion:
(anaphoric ignore-first (1+ 1) (progn it (1+ it)))
You are a Common Lisp macro expert. Given this code pattern:
(when (slot-value parent 'tail-qualifiers) (format stream " "))

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 (slot-value parent (quote tail-qualifiers)) (format stream " "))
You are a Common Lisp macro expert. Given this code pattern:
(do () (progn))

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

Macro definition:
(defmacro DO ...)

Macroexpansion:
(block nil
  (let ()
    (declare (ignorable))
    (tagbody
      (go #:g193)
     #:g192
      (tagbody)
      (psetq)
     #:g193
      (unless progn (go #:g192))
      (return-from nil (progn)))))
Define a macro that eliminates this repetitive pattern:
(collect-first nil)

Issue: Macro call that should be transformed by COLLECT-FIRST

Macro definition:
(defmacro COLLECT-FIRST ...)

Macroexpansion:
(common-lisp:let* ((#:generator-616 (generator nil))
                   #:items-610
                   (#:item-612 nil))
  (declare (type generator #:generator-616)
           (type (null-or t) #:item-612))
  (tagbody
   #:ll-617
    (setq #:items-610 (next-in #:generator-616 (go end)))
    (setq #:item-612 #:items-610)
   end)
  #:item-612)
You are a Common Lisp macro expert. Given this code pattern:
(with-html-string (:p "foo" "bar" (values "baz")))

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

Macro definition:
(defmacro with-html (&body body &environment env)
  "Interpret BODY as HTML. Consult README.txt for the syntax."
  `(let ((*html* (ensure-html-stream *html*)))
     ,(if (and (null (cdr body)) (atom (car body)))
          (car body)
          `(progn ,@(parse-html body env)))))

Macroexpansion:
(with-output-to-string (*html*) (with-html (:p "foo" "bar" (values "baz"))))
Define a macro that eliminates this repetitive pattern:
(define-path-instruction-pair smooth-quadratic-curve-to "T" (x y))

Issue: Macro call that should be transformed by define-path-instruction-pair

Macro definition:
(defmacro define-path-instruction-pair (name instruction (&rest args))
  (let ((draw-relative (intern (concatenate 'string (string name) "-R"))))
    `(progn
       (defun ,name (,@args)
         (format-instruction ,instruction ,@args))
       (defun ,draw-relative (,@args)
         (format-instruction ,(string-downcase instruction) ,@args)))))

Macroexpansion:
(progn (defun smooth-quadratic-curve-to (x y) (format-instruction "T" x y)) (defun smooth-quadratic-curve-to-r (x y) (format-instruction "t" x y)))
Define a macro that eliminates this repetitive pattern:
(list-of nil
  nil)

Issue: Macro call that should be transformed by LIST-OF

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

Macroexpansion:
(lc (nil nil) collect)
You are a Common Lisp macro expert. Given this code pattern:
(with-html-string (:p "foo" "bar" "baz"))

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

Macro definition:
(defmacro with-html (&body body &environment env)
  "Interpret BODY as HTML. Consult README.txt for the syntax."
  `(let ((*html* (ensure-html-stream *html*)))
     ,(if (and (null (cdr body)) (atom (car body)))
          (car body)
          `(progn ,@(parse-html body env)))))

Macroexpansion:
(with-output-to-string (*html*) (with-html (:p "foo" "bar" "baz")))
Define a macro that eliminates this repetitive pattern:
(defun-speedy ascii-string-to-octets (string) (%ascii-string-to-octets string))

Issue: Macro call that should be transformed by defun-speedy

Macro definition:
(defmacro defun-speedy (name lambda-list &body body)
  `(progn
     (declaim (notinline ,name))
     (defun ,name ,lambda-list
       ,*speedy-declaration*
       ,@body)))

Macroexpansion:
(progn (declaim (notinline ascii-string-to-octets)) (defun ascii-string-to-octets (string) (declare (optimize (speed 3) (safety 0) (space 0) (compilation-speed 0))) (%ascii-string-to-octets string)))
You are a Common Lisp macro expert. Given this code pattern:
(lret* ((shape (ensure-shape shape)) (array (make-array shape))) (loop for i from 0 below (array-total-size array) do (setf (row-major-aref array i) (array-index-row-major array i))))

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

Macro definition:
(defmacro lret ((&rest bindings) &body body)
  "Return the initial value of the last binding in BINDINGS. The idea
is to create something, initialize it, and then return it.

    (lret ((x 1)
           (y (make-array 1)))
      (setf (aref y 0) x))
    => #(1)

Note that the value returned is the value initially bound. Subsequent
assignments are ignored.

    (lret ((x 1))
      (setf x 2))
    => 1

Furthermore, on Lisps that support it, the variable may be made
read-only, making assignment a compiler-time error.

`lret' may seem trivial, but it fufills the highest purpose a macro
can: it eliminates a whole class of bugs (initializing an object, but
forgetting to return it).

Cf. `aprog1' in Anaphora."
  `(lret-aux let ,bindings
     ,@body))

Macroexpansion:
(lret-aux let* ((shape (ensure-shape shape)) (array (make-array shape))) (loop for i from 0 below (array-total-size array) do (setf (row-major-aref array i) (array-index-row-major array i))))
Write a Common Lisp macro to handle this code pattern:
(do-immutable-map (_ value object) (declare (ignore _)) (scan value))

Problem: Macro call that should be transformed by do-immutable-map

Macro definition:
(defmacro do-immutable-map ((key value map &optional result) &body body)
  "Iterate over MAP in ascending key order, binding KEY and VALUE."
  `(avl:do-avl (,key ,value (immutable-map-data ,map) ,result)
     ,@body))

Macroexpansion:
(avl:do-avl (_ value (immutable-map-data object) nil) (declare (ignore _)) (scan value))
Define a macro that eliminates this repetitive pattern:
(with-lock (lru-pool-lock pool) (add-to-lru-pool pool host-port stream eviction-callback))

Issue: Macro call that should be transformed by with-lock

Macro definition:
(defmacro with-lock (lock &body body)
  (declare (ignorable lock))
  #+thread-support `(bt2:with-lock-held (,lock)
                      ,@body)
  #-thread-support `(progn ,@body))

Macroexpansion:
(bt2:with-lock-held ((lru-pool-lock pool)) (add-to-lru-pool pool host-port stream eviction-callback))
You are a Common Lisp macro expert. Given this code pattern:
(with-yield-binds (format nil (if (sql-statement-p (statement-clause-statement clause)) "~:[~A ~;~*~](~A)" "~:[~A ~;~*~]~A") (string= (sql-clause-name clause) "") (sql-clause-name clause) (yield (statement-clause-statement 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 (if (sql-statement-p (statement-clause-statement clause)) "~:[~A ~;~*~](~A)" "~:[~A ~;~*~]~A") (string= (sql-clause-name clause) "") (sql-clause-name clause) (yield (statement-clause-statement clause)))) (loop for bind in (reverse *bind-values*) append bind)))
Define a macro that eliminates this repetitive pattern:
(with-decoder-simple-list-semantics (let (result) (setf result (json-rpc:invoke-rpc (format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"method\":\"~a\",\"params\":[1,2],\"id\":999}" (json-rpc-2-p) method-name))) (is (string= result (format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"result\":{\"digits\":3,\"letters\":\"three\"},~@[~*\"error\":null,~]\"id\":999}" (json-rpc-2-p) (not (json-rpc-2-p)))))))

Issue: Macro call that should be transformed by with-decoder-simple-list-semantics

Macro definition:
(defmacro with-decoder-simple-list-semantics (&body body)
  "Execute BODY in a dynamic environement where the decoder semantics
is such as set by SET-DECODER-SIMPLE-LIST-SEMANTICS."
  `(with-shadowed-custom-vars
     (set-decoder-simple-list-semantics)
     ,@body))

Macroexpansion:
(with-shadowed-custom-vars (set-decoder-simple-list-semantics) (let (result) (setf result (json-rpc:invoke-rpc (format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"method\":\"~a\",\"params\":[1,2],\"id\":999}" (json-rpc-2-p) method-name))) (is (string= result (format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"result\":{\"digits\":3,\"letters\":\"three\"},~@[~*\"error\":null,~]\"id\":999}" (json-rpc-2-p) (not (json-rpc-2-p)))))))
Define a macro that eliminates this repetitive pattern:
(make-avl-map ('foo val1) ('bar val2))

Issue: Macro call that should be transformed by make-avl-map

Macro definition:
(defmacro make-avl-map (&rest pairs)
  "Construct an AVL tree from literal (key-expr value-expr) pairs.
Usage: (make-avl-map ('foo val1) ('bar val2))"
  (let ((tree (gensym "TREE")))
    `(let ((,tree (empty-avl-tree)))
       ,@(loop :for (k v) :in pairs
               :collect `(setf ,tree (avl-set ,tree ,k ,v)))
       ,tree)))

Macroexpansion:
(let ((#:tree162 (empty-avl-tree))) (setf #:tree162 (avl-set #:tree162 (quote foo) val1)) (setf #:tree162 (avl-set #:tree162 (quote bar) val2)) #:tree162)
Generate a defmacro form that transforms code like this:
(defalias path:root-p (pathname) cl-fad:pathname-root-p)

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

Macro definition:
(defmacro defalias (name args realname)
  `(progn
     (defun ,name ,args
       ,(if (eql '&rest (first args))
            `(apply #',realname ,(second args))
            `(,realname ,@args)))
     (define-compiler-macro ,name (&rest args)
       (list* ',realname args))))

Macroexpansion:
(progn (defun path:root-p (pathname) (pathname-root-p pathname)) (define-compiler-macro path:root-p (&rest args) (list* (quote pathname-root-p) args)))
Write a Common Lisp macro to handle this code pattern:
(define-modf-rewrite rest (expr) `(cdr ,(second expr)))

Problem: Macro call that should be transformed by define-modf-rewrite

Macro definition:
(defmacro define-modf-rewrite (name (expr) &body body)
  "Define a new rewrite rule.  If a form starting with NAME is encountered, call
the defined function to return a form that we can deal with (i.e. one defined
via DEFINE-MODF-EXPANDER, DEFINE-MODF-FUNCTION, and DEFINE-MODF-METHOD)."
  `(eval-when (:compile-toplevel :load-toplevel :execute)
     (setf (gethash ',name *modf-rewrites*)
           (lambda (,expr)
             ,@body))))

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute) (setf (gethash (quote rest) *modf-rewrites*) (lambda (expr) (sb-int:quasiquote (cdr #S(sb-impl::comma :expr (second expr) :kind 0))))))
Generate a defmacro form that transforms code like this:
(as->* nil :key nil)

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

Macro definition:
(defmacro AS->* ...)

Macroexpansion:
(as-> nil nil :key)
Create a Common Lisp macro for the following transformation. Before code:
(define-error for-loop-simple-expression () () "Only simple expressions are allowed in the condition and update slots of a for loop")

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

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

Macroexpansion:
(defcondition for-loop-simple-expression (:error-type varjo-error :prefix "Varjo") nil "Only simple expressions are allowed in the condition and update slots of a for loop")
Write a Common Lisp macro to handle this code pattern:
(define HUGE_VAL most-positive-double-float)

Problem: 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 huge_val) *preprocessor-defines*) #A((26) base-char . "MOST-POSITIVE-DOUBLE-FLOAT"))) (defparameter huge_val most-positive-double-float))
Generate a defmacro form that transforms code like this:
(define-direct-binding being (var &rest sub-bindings) (let ((bindings (loop for bind in sub-bindings collect (list* var bind))) (being-counter (gensym (string 'being-counter))) (being-tag (gensym (string 'being-tag))) (vars (loop for var in (lambda-fiddle:extract-lambda-vars (enlist var)) collect `(,var NIL)))) (multiple-value-bind (bind-init bind-forms) (convert-bindings bindings) (values `(with-interleaving (let ((,being-counter 0) ,@vars)) ,@(loop for bind in bind-init collect (remove-bindings vars bind))) `(tagbody ,being-tag (case ,being-counter ,@(loop for form in (butlast bind-forms) for i from 0 collect `(,i (macrolet ((end-for () `(progn (incf ,',being-counter) (go ,',being-tag)))) ,form))) (T ,@(last bind-forms))))))))

Pattern to recognize: Macro call that should be transformed by define-direct-binding

Macro definition:
(defmacro define-direct-binding (name args &body body)
  (let ((env (or (lambda-fiddle:environment-lambda-var args) (gensym "ENVIRONMENT"))))
    `(progn (setf (binding ',name)
                  (lambda ,(lambda-fiddle:remove-environment-part args)
                    (let ((,env *environment*))
                      (declare (ignorable ,env))
                      ,@body)))
            ',name)))

Macroexpansion:
(progn (setf (binding (quote being)) (lambda (var &rest sub-bindings) (let ((#:environment124 *environment*)) (declare (ignorable #:environment124)) (let ((bindings (loop for bind in sub-bindings collect (list* var bind))) (being-counter (gensym (string (quote being-counter)))) (being-tag (gensym (string (quote being-tag)))) (vars (loop for var in (lambda-fiddle:extract-lambda-vars (enlist var)) collect (sb-int:quasiquote (#S(sb-impl::comma :expr var :kind 0) nil))))) (multiple-value-bind (bind-init bind-forms) (convert-bindings bindings) (values (sb-int:quasiquote (with-interleaving (let ((#S(sb-impl::comma :expr being-counter :kind 0) 0) #S(sb-impl::comma :expr vars :kind 2))) #S(sb-impl::comma :expr (loop for bind in bind-init collect (remove-bindings vars bind)) :kind 2))) (sb-int:quasiquote (tagbody #S(sb-impl::comma :expr being-tag :kind 0) (case #S(sb-impl::comma :expr being-counter :kind 0) #S(sb-impl::comma :expr (loop for form in (butlast bind-forms) for i from 0 collect (sb-int:quasiquote (#S(sb-impl::comma :expr i :kind 0) (macrolet ((end-for nil (sb-int:quasiquote (progn (incf #S(sb-impl::comma :expr (quote #S(sb-impl::comma :expr being-counter :kind 0)) :kind 0)) (go #S(sb-impl::comma :expr (quote #S(sb-impl::comma :expr being-tag :kind 0)) :kind 0)))))) #S(sb-impl::comma :expr form :kind 0))))) :kind 2) (t #S(sb-impl::comma :expr (last bind-forms) :kind 2))))))))))) (quote being))
Write a Common Lisp macro to handle this code pattern:
(gatherer nil)

Problem: Macro call that should be transformed by GATHERER

Macro definition:
(defmacro GATHERER ...)

Macroexpansion:
(common-lisp:let ((#:lastcons-445 (list nil)) #:lst-446)
  (declare (type cons #:lastcons-445)
           (type list #:lst-446))
  (setq #:lst-446 #:lastcons-445)
  (common-lisp:let (#:out-448)
    #'(lambda (#:items-444 result-p)
        (cond
         ((null result-p)
          (tagbody
            (setq #:lastcons-445
                    (setf (cdr #:lastcons-445) (cons #:items-444 nil)))))
         (t
          (progn
           (setq #:lst-446 (cdr #:lst-446))
           (setq #:out-448
                   (common-lisp:funcall nil
                                        (common-lisp:funcall #'scan
                                                             #:lst-446))))
          #:out-448)))))
Create a Common Lisp macro for the following transformation. Before code:
(def-dynenv-fun nil
    nil)

What needs to change: Macro call that should be transformed by DEF-DYNENV-FUN

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

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defun nil (&rest #:args) (apply (dynenv-function nil) #:args))
  (defvar #:nil143 (lambda ()))
  (setf (get 'nil 'dynenv-fun) '#:nil143))