j14i/cl-macros huggingface dataset:
Create a Common Lisp macro for the following transformation. Before code:
(ps-once-only nil)

What needs to change: Macro call that should be transformed by PS-ONCE-ONLY

Macro definition:
(defmacro PS-ONCE-ONLY ...)

Macroexpansion:
(let* ()
  `(let* ()
     ,(let* ())))
You are a Common Lisp macro expert. Given this code pattern:
(builder :session (lambda (env) (unless (gethash :counter (getf env :lack.session)) (setf (gethash :counter (getf env :lack.session)) 0)) `(200 (:content-type "text/plain") (,(format nil "Hello, you've been here for ~Ath times!" (incf (gethash :counter (getf env :lack.session))))))))

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

Macro definition:
(defmacro builder (&rest app-or-middlewares)
  (let ((middlewares (butlast app-or-middlewares)))
    `(reduce #'funcall
             (remove-if
              #'null
              (list
               ,@(loop for mw in middlewares
                       when mw
                         collect (convert-to-middleware-form mw))))
             :initial-value (to-app ,(car (last app-or-middlewares)))
             :from-end t)))

Macroexpansion:
(reduce (function funcall) (remove-if (function null) (list (find-middleware :session))) :initial-value (to-app (lambda (env) (unless (gethash :counter (getf env :lack.session)) (setf (gethash :counter (getf env :lack.session)) 0)) (sb-int:quasiquote (200 (:content-type "text/plain") (#S(sb-impl::comma :expr (format nil "Hello, you've been here for ~Ath times!" (incf (gethash :counter (getf env :lack.session)))) :kind 0)))))) :from-end t)
Define a macro that eliminates this repetitive pattern:
(define-type-dispatch nil
    nil)

Issue: Macro call that should be transformed by DEFINE-TYPE-DISPATCH

Macro definition:
(defmacro DEFINE-TYPE-DISPATCH ...)

Macroexpansion:
(progn
 (defun nil ()
   (declare (optimize speed (debug 1) (safety 1) (compilation-speed 0)))
   (etypecase nil))
 (sb-c:defknown nil
     nil
     (or)
     (sb-c:any)
   :overwrite-fndb-silently
   t))
Write a Common Lisp macro to handle this code pattern:
(-<>>
  nil
  :key
  nil)

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

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

Macroexpansion:
(let* ((#:var124 nil) (#:var125 (:key #:var124)) (#:var126 (nil #:var125)))
  #:var126)
Create a Common Lisp macro for the following transformation. Before code:
(define-mustache-character #\& (make-instance 'ampersand-tag :text arg-text))

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

Macro definition:
(defmacro define-mustache-character (char &body body)
  `(set-mustache-character
    ,char (lambda (raw-text arg-text escapep start end)
            (declare (ignorable raw-text arg-text escapep start end)
                     (type simple-string raw-text arg-text)
                     (boolean escapep)
                     (offset start end))
            ,@body)))

Macroexpansion:
(set-mustache-character #\AMPERSAND (lambda (raw-text arg-text escapep start end) (declare (ignorable raw-text arg-text escapep start end) (type simple-string raw-text arg-text) (boolean escapep) (offset start end)) (make-instance (quote ampersand-tag) :text arg-text)))
Create a Common Lisp macro for the following transformation. Before code:
(-> :g () (error 'recoverable-condition))

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

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

Macroexpansion:
(atomically :g nil (error (quote recoverable-condition)))
You are a Common Lisp macro expert. Given this code pattern:
(when (node-slot virtual) (format stream "virtual "))

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 (node-slot virtual) (format stream "virtual "))
Generate a defmacro form that transforms code like this:
(define-error var-type-mismatch () (var-type code-obj) "Type specified does not match the type of the form~%~s~%~s" (primary-type code-obj) var-type)

Pattern to recognize: 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 var-type-mismatch (:error-type varjo-error :prefix "Varjo") (var-type code-obj) "Type specified does not match the type of the form~%~s~%~s" (primary-type code-obj) var-type)
Write a Common Lisp macro to handle this code pattern:
(deferror "26000" invalid-sql-statement-name)

Problem: 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 invalid-sql-statement-name (database-error) nil) (setf (gethash "26000" *error-table*) (quote invalid-sql-statement-name)))
Create a Common Lisp macro for the following transformation. Before code:
(define-modf-rewrite caddr (expr) `(car (cddr ,(second expr))))

What needs to change: 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 caddr) *modf-rewrites*) (lambda (expr) (sb-int:quasiquote (car (cddr #S(sb-impl::comma :expr (second expr) :kind 0)))))))
Define a macro that eliminates this repetitive pattern:
(ematch0 more-patterns (nil body) ((list generator) (error "Odd number of elements in {generator subpattern}*: subpattern for ~a missing!" generator)) ((list* generator subpattern more-patterns) (match-clause generator subpattern (let ((*lexvars* (append (variables subpattern) *lexvars*))) (destructure-guard1-subpatterns more-patterns body)))))

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 more-patterns (nil body) ((list generator) (error "Odd number of elements in {generator subpattern}*: subpattern for ~a missing!" generator)) ((list* generator subpattern more-patterns) (match-clause generator subpattern (let ((*lexvars* (append (variables subpattern) *lexvars*))) (destructure-guard1-subpatterns more-patterns body)))) (_ (error "level0 match error!")))
You are a Common Lisp macro expert. Given this code pattern:
(defpackage nil nil)

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

Macro definition:
(defmacro DEFPACKAGE ...)

Macroexpansion:
(prog1
    (common-lisp:defpackage nil
      (nil)))
You are a Common Lisp macro expert. Given this code pattern:
(defsynonym minimize :min)

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

Macro definition:
(defmacro defsynonym (symbol synonym)
  "Set SYNONYM for a SYMBOL. "
  `(eval-always
     (setf (get ',symbol 'synonym) ',synonym)))

Macroexpansion:
(eval-always (setf (get (quote minimize) (quote synonym)) (quote :min)))
Create a Common Lisp macro for the following transformation. Before code:
(when (eql (top-info) 'aref) (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 (eql (top-info) (quote aref)) (format stream "("))
You are a Common Lisp macro expert. Given this code pattern:
(define-method-combination nil)

Write a macro that addresses: Macro call that should be transformed by DEFINE-METHOD-COMBINATION

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

Macroexpansion:
(progn
 (sb-kernel:with-single-package-locked-error (:symbol 'nil
                                              #A((35) base-char
                                                 . "defining ~A as a method combination")))
 (sb-pcl::load-short-defcombin 'nil 'nil 'nil nil (sb-c:source-location)))
Write a Common Lisp macro to handle this code pattern:
(define-simple-clause thereis (form &key key &aux (result NIL)) (let ((res (gensym "RES"))) (values `(let ((,res ,form)) (when ,(if key `(funcall ,key ,res) res) (setf ,result ,res) (end-for))) result)))

Problem: Macro call that should be transformed by define-simple-clause

Macro definition:
(defmacro define-simple-clause (name args &body body)
  (multiple-value-bind (args outer-let inner-let result-let) (compute-binding-parts NIL NIL args)
    `(define-direct-clause ,name ,(rest args)
       (let ,outer-let
         (values* `(let* ,(list
                           ,@result-let)
                     (declare (ignorable ,,@(mapcar #'delist outer-let))))
                  (let ,inner-let
                    (declare (ignorable ,@(mapcar #'delist inner-let)))
                    ,@body))))))

Macroexpansion:
(define-direct-clause thereis (form &key key) (let ((#:result189 (gensym #A((6) base-char . "RESULT")))) (values* (sb-int:quasiquote (let* #S(sb-impl::comma :expr (list (list #:result189 nil)) :kind 0) (declare (ignorable #S(sb-impl::comma :expr #:result189 :kind 0))))) (let ((result #:result189)) (declare (ignorable result)) (let ((res (gensym "RES"))) (values (sb-int:quasiquote (let ((#S(sb-impl::comma :expr res :kind 0) #S(sb-impl::comma :expr form :kind 0))) (when #S(sb-impl::comma :expr (if key (sb-int:quasiquote (funcall #S(sb-impl::comma :expr key :kind 0) #S(sb-impl::comma :expr res :kind 0))) res) :kind 0) (setf #S(sb-impl::comma :expr result :kind 0) #S(sb-impl::comma :expr res :kind 0)) (end-for)))) result))))))
You are a Common Lisp macro expert. Given this code pattern:
(the-part)

Write a macro that addresses: Macro call that should be transformed by THE-PART

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

Macroexpansion:
(send part)
Define a macro that eliminates this repetitive pattern:
(with-env [ht-eq (string (alexandria:copy-array \"a\"))])")))

Issue: 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 (#:g125) (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 #:g125 (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)) [ht-eq (string (alexandria:copy-array |"A"|)) ])) (setf (find-class (quote foo) nil) nil) (setf (find-class (quote bar) nil) nil) #:g125)
Create a Common Lisp macro for the following transformation. Before code:
(lambda-match0 ((cons key pattern) `(property ,key ,pattern)))

What needs to change: Macro call that should be transformed by lambda-match0

Macro definition:
(defmacro lambda-match0 (&body clauses)
  (alexandria:with-gensyms (arg)
    `(lambda (,arg)
       (match0 ,arg
         ,@clauses))))

Macroexpansion:
(lambda (#:arg166) (match0 #:arg166 ((cons key pattern) (sb-int:quasiquote (property #S(sb-impl::comma :expr key :kind 0) #S(sb-impl::comma :expr pattern :kind 0))))))
You are a Common Lisp macro expert. Given this code pattern:
(define-accumulation-binding nconcing (var form &aux (head (cons NIL NIL)) (tail head)) (declare (type list var) (type cons head tail)) (let ((result (gensym "RESULT"))) `(let ((,result ,form)) (when ,result (setf (cdr ,tail) ,result ,tail (last ,result)) (setf ,var (cdr ,head))))))

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

Macro definition:
(defmacro define-accumulation-binding (name (var &rest args) &body body)
  `(define-form-binding ,name (,var ,@args)
     ,@(form-fiddle:lambda-declarations `(lambda () ,@body))
     (values
      (progn ,@(form-fiddle:lambda-forms `(lambda () ,@body)))
      (delist var))))

Macroexpansion:
(define-form-binding nconcing (var form &aux (head (cons nil nil)) (tail head)) (declare (type list var) (type cons head tail)) (values (progn (let ((result (gensym "RESULT"))) (sb-int:quasiquote (let ((#S(sb-impl::comma :expr result :kind 0) #S(sb-impl::comma :expr form :kind 0))) (when #S(sb-impl::comma :expr result :kind 0) (setf (cdr #S(sb-impl::comma :expr tail :kind 0)) #S(sb-impl::comma :expr result :kind 0) #S(sb-impl::comma :expr tail :kind 0) (last #S(sb-impl::comma :expr result :kind 0))) (setf #S(sb-impl::comma :expr var :kind 0) (cdr #S(sb-impl::comma :expr head :kind 0)))))))) (delist var)))
Create a Common Lisp macro for the following transformation. Before code:
(*> +opt-fws+ #'many-dtext1)

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

Macro definition:
(defmacro *> (parser &rest parsers)
  "Combination of parsers yielding the result of the rightmost one."
  (let ((offset (gensym "*>-OFFSET")))
    `(lambda (,offset)
       ,(reduce (lambda (i p)
                  (let ((res  (gensym "*>-RES"))
                        (next (gensym "*>-NEXT")))
                    `(multiple-value-bind (,res ,next) ,i
                       (if (ok? ,res)
                           (funcall ,p ,next)
                           (fail ,next)))))
                parsers
                :initial-value `(funcall ,parser ,offset)))))

Macroexpansion:
(lambda (#:*>-offset152) (multiple-value-bind (#:*>-res153 #:*>-next154) (funcall +opt-fws+ #:*>-offset152) (if (ok? #:*>-res153) (funcall (function many-dtext1) #:*>-next154) (fail #:*>-next154))))
Define a macro that eliminates this repetitive pattern:
(cond-<>>)

Issue: Macro call that should be transformed by COND-<>>

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

Macroexpansion:
nil
Define a macro that eliminates this repetitive pattern:
(for nil
    (progn))

Issue: Macro call that should be transformed by FOR

Macro definition:
(defmacro FOR ...)

Macroexpansion:
(let ((#:|generator!121| (progn)))
  (assert (typep #:|generator!121| 'generator!))
  (unwind-protect
      (loop :while (has-next-p #:|generator!121|)
            :do (let ((nil (next #:|generator!121|))))))
  (stop #:|generator!121|))
Write a Common Lisp macro to handle this code pattern:
(compiler-macro-lambda (a b) `(+ ,a ,b))

Problem: Macro call that should be transformed by compiler-macro-lambda

Macro definition:
(defmacro compiler-macro-lambda (lambda-list &body body)
  (introspect-environment:parse-compiler-macro (gensym "COMPILER-MACRO-LAMBDA")
                                               lambda-list
                                               body))

Macroexpansion:
(sb-int:named-lambda (compiler-macro #:compiler-macro-lambda147) (#:expr #:env) (declare (sb-c::lambda-list (a b))) (declare (ignore #:env)) (sb-int:named-ds-bind (:macro #:compiler-macro-lambda147 . define-compiler-macro) (a b) (sb-c::compiler-macro-args #:expr) (declare (sb-c::constant-value a b) (sb-c::no-compiler-macro #:compiler-macro-lambda147)) (block #:compiler-macro-lambda147 (sb-int:quasiquote (+ #S(sb-impl::comma :expr a :kind 0) #S(sb-impl::comma :expr b :kind 0))))))
You are a Common Lisp macro expert. Given this code pattern:
(resolve
  nil
  (progn))

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

Macro definition:
(defmacro RESOLVE ...)

Macroexpansion:
(locally
 (declare)
 (multiple-value-bind (#:assignment151 #:unified-p152)
     (type-unify 'nil 'nil (list))
   (assert #:unified-p152 nil 'simple-type-error :format-control
           "gtypes failed to unify to the actual types:~% ~a~%    against~% ~a"
           :format-arguments (list 'nil (list)))
   (let ()
     (declare (ignorable))
     nil
     (progn))))
You are a Common Lisp macro expert. Given this code pattern:
($/ query "i")

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

Macro definition:
(defmacro $/ (regex options)
  `(make-bson-regex (empty-str ,regex) ,options))

Macroexpansion:
(make-bson-regex (empty-str query) "i")
Create a Common Lisp macro for the following transformation. Before code:
(f0)

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

Macro definition:
(defmacro F0 ...)

Macroexpansion:
(lambda ())
Define a macro that eliminates this repetitive pattern:
(lret ((out (make-array shape :element-type (array-element-type array)))) (replace* (%flatten out) array))

Issue: 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 ((out (make-array shape :element-type (array-element-type array)))) (replace* (%flatten out) array))
Write a Common Lisp macro to handle this code pattern:
(dynamic-reprogv nil
    nil)

Problem: Macro call that should be transformed by DYNAMIC-REPROGV

Macro definition:
(defmacro DYNAMIC-REPROGV ...)

Macroexpansion:
(dynamic-wind
  :proceed
  #:proceed198
  (let* ((#:computed-symbols196 nil)
         (#:computed-bindings197 (compute-bindings #:computed-symbols196 nil)))
    (progv #:computed-symbols196 #:computed-bindings197 (#:proceed198))))
You are a Common Lisp macro expert. Given this code pattern:
(with-unique-names (this-s) (setf (get s-indicator current-s-indicator) this-s) `(let* ((it ,test) (,this-s it)) (declare (ignorable ,this-s)) (,op it ,@body)))

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

Macro definition:
(defmacro with-unique-names ((&rest bindings) &body body)
  `(let ,(mapcar #'(lambda (binding)
		     (destructuring-bind (var prefix)
			 (if (consp binding) binding (list binding binding))
		       `(,var (gensym ,(string prefix)))))
		 bindings)
     ,@body))

Macroexpansion:
(let ((this-s (gensym #A((7) base-char . "THIS-S-")))) (setf (get s-indicator current-s-indicator) this-s) (quasiquote (let* ((it #S(sb-impl::comma :expr test :kind 0)) (#S(sb-impl::comma :expr this-s :kind 0) it)) (declare (ignorable #S(sb-impl::comma :expr this-s :kind 0))) (#S(sb-impl::comma :expr op :kind 0) it #S(sb-impl::comma :expr body :kind 2)))))
Generate a defmacro form that transforms code like this:
(builder :session (lambda (env) (unless (gethash :counter (getf env :lack.session)) (setf (gethash :counter (getf env :lack.session)) 0)) (lambda (responder) (funcall responder `(200 (:content-type "text/plain") (,(format nil "Hello, you've been here for ~Ath times!" (incf (gethash :counter (getf env :lack.session))))))))))

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

Macro definition:
(defmacro builder (&rest app-or-middlewares)
  (let ((middlewares (butlast app-or-middlewares)))
    `(reduce #'funcall
             (remove-if
              #'null
              (list
               ,@(loop for mw in middlewares
                       when mw
                         collect (convert-to-middleware-form mw))))
             :initial-value (to-app ,(car (last app-or-middlewares)))
             :from-end t)))

Macroexpansion:
(reduce (function funcall) (remove-if (function null) (list (find-middleware :session))) :initial-value (to-app (lambda (env) (unless (gethash :counter (getf env :lack.session)) (setf (gethash :counter (getf env :lack.session)) 0)) (lambda (responder) (funcall responder (sb-int:quasiquote (200 (:content-type "text/plain") (#S(sb-impl::comma :expr (format nil "Hello, you've been here for ~Ath times!" (incf (gethash :counter (getf env :lack.session)))) :kind 0)))))))) :from-end t)
Define a macro that eliminates this repetitive pattern:
(define-port-value-slot nil :key nil)

Issue: Macro call that should be transformed by DEFINE-PORT-VALUE-SLOT

Macro definition:
(defmacro DEFINE-PORT-VALUE-SLOT ...)

Macroexpansion:
(progn
 (defmethod port-value ((nil nil)) (slot-value nil :key))
 (defmethod (setf port-value) (value (nil nil))
   (setf (slot-value nil :key) value))
 (defmethod port-value-boundp ((nil nil)) (slot-boundp nil ':key))
 (defmethod port-value-makunbound ((nil nil)) (slot-makunbound nil ':key)))
Write a Common Lisp macro to handle this code pattern:
(define-declaration nil
    :key
  nil)

Problem: Macro call that should be transformed by DEFINE-DECLARATION

Macro definition:
(defmacro DEFINE-DECLARATION ...)

Macroexpansion:
(sb-cltl2:define-declaration nil
    :key
  nil)
You are a Common Lisp macro expert. Given this code pattern:
(progf '(foo) (list (lambda () 23)) (is (eql 23 (foo))))

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

Macro definition:
(defmacro progf (functions values &body body)
  "Like PROGV, but for FUNCTIONS."
  `(call-with-function-bindings ,functions ,values (lambda () ,@body)))

Macroexpansion:
(call-with-function-bindings (quote (foo)) (list (lambda nil 23)) (lambda nil (is (eql 23 (foo)))))