j14i/cl-macros huggingface dataset:
Define a macro that eliminates this repetitive pattern:
(with-yield-binds (if (cdr (conjunctive-op-expressions op)) (format nil (format nil "(~~{~~A~~^ ~A ~~})" (sql-op-name op)) (mapcar #'yield (conjunctive-op-expressions op))) (yield (car (conjunctive-op-expressions op)))))

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 (if (cdr (conjunctive-op-expressions op)) (format nil (format nil "(~~{~~A~~^ ~A ~~})" (sql-op-name op)) (mapcar (function yield) (conjunctive-op-expressions op))) (yield (car (conjunctive-op-expressions op))))) (loop for bind in (reverse *bind-values*) append bind)))
Write a Common Lisp macro to handle this code pattern:
(parse-conjunctive-clauses client instance t)

Problem: Macro call that should be transformed by parse-conjunctive-clauses

Macro definition:
(defmacro parse-conjunctive-clauses (client region read-name-p &rest args)
  (with-unique-names (clauses next)
    `(prog (,clauses)
      ,next
        (push (do-parse-clause ,client ,region *index* ,read-name-p ,@args)
              ,clauses)
        (when (maybe-parse-token :keywords '(:and))
          (go ,next))
        (return (nreverse ,clauses)))))

Macroexpansion:
(prog (#:clauses122) #:next123 (push (do-parse-clause client instance *index* t) #:clauses122) (when (maybe-parse-token :keywords (quote (:and))) (go #:next123)) (return (nreverse #:clauses122)))
Define a macro that eliminates this repetitive pattern:
(f nil
  nil)

Issue: Macro call that should be transformed by F

Macro definition:
(defmacro F ...)

Macroexpansion:
(lambda () nil)
Generate a defmacro form that transforms code like this:
(special-symbol-progv nil
    (progn))

Pattern to recognize: Macro call that should be transformed by SPECIAL-SYMBOL-PROGV

Macro definition:
(defmacro SPECIAL-SYMBOL-PROGV ...)

Macroexpansion:
(let (#:symbol-list178)
  (tagbody
   #:retry179
    (setq #:symbol-list178 nil)
    (unless (every #'special-symbol-p #:symbol-list178)
      (cerror "Retry to rebind the place(s)."
              "Attempt at rebinding one or more non-special places: ~S" 'nil)
      (go #:retry179)))
  (dynamic-progv #:symbol-list178
      (progn)))
Create a Common Lisp macro for the following transformation. Before code:
(defmacro* nil
    :key
  nil)

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

Macro definition:
(defmacro DEFMACRO* ...)

Macroexpansion:
(defmacro nil :key
  `(with-yield
     ,nil))
Write a Common Lisp macro to handle this code pattern:
(c-assert (or (null (fm-parent kid)) (eql fm-parent (fm-parent kid))))

Problem: Macro call that should be transformed by c-assert

Macro definition:
(defmacro c-assert (assertion &optional places fmt$ &rest fmt-args)
  (declare (ignorable assertion places fmt$ fmt-args))
   #+(or)`(progn) 
  `(unless *stop*
     (unless ,assertion
       ,(if fmt$
            `(c-break ,fmt$ ,@fmt-args)
          `(c-break "failed assertion: ~a" ',assertion)))))

Macroexpansion:
(unless *stop* (unless (or (null (fm-parent kid)) (eql fm-parent (fm-parent kid))) (c-break "failed assertion: ~a" (quote (or (null (fm-parent kid)) (eql fm-parent (fm-parent kid)))))))
Write a Common Lisp macro to handle this code pattern:
(odig nil)

Problem: Macro call that should be transformed by ODIG

Macro definition:
(defmacro ODIG ...)

Macroexpansion:
(odig 1 nil)
Define a macro that eliminates this repetitive pattern:
(when (first in-decl) (pop in-decl-item))

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 (first in-decl) (pop in-decl-item))
You are a Common Lisp macro expert. Given this code pattern:
(resolve
  'some-name)

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

Macro definition:
(defmacro RESOLVE ...)

Macroexpansion:
(locally
 (declare)
 (multiple-value-bind (#:assignment155 #:unified-p156)
     (type-unify 'nil 'nil (list))
   (assert #:unified-p156 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))
     'some-name)))
Write a Common Lisp macro to handle this code pattern:
(defun/1 getchar () (getc stdin))

Problem: Macro call that should be transformed by defun/1

Macro definition:
(defmacro defun/1 (name arglist &body body)
  "Lisp-1 defun; makes function pointers work."
  `(progn
     (defun ,name ,arglist
       (declare (optimize (speed 0) (debug 3)
                          ;; FIXME: Why do minor warnings result in load errors?
                          #+sbcl (sb-ext:inhibit-warnings 3)))
        
       ,@body)
     (defparameter ,name (vacietis.c:mkptr& (symbol-function ',name)))))

Macroexpansion:
(progn (defun getchar nil (declare (optimize (speed 0) (debug 3) (sb-ext:inhibit-warnings 3))) (getc stdin)) (defparameter getchar (vacietis.c:mkptr& (symbol-function (quote getchar)))))
Define a macro that eliminates this repetitive pattern:
(def$frame nil :key nil)

Issue: Macro call that should be transformed by DEF$FRAME

Macro definition:
(defmacro DEF$FRAME ...)

Macroexpansion:
(def$flavor nil :key nil)
Write a Common Lisp macro to handle this code pattern:
(with-wrap-attempt () name (define-foreign-type name (make-instance 'foreign-alias :name name :type (ensure-type type "alias of type ~S to ~S" type name))))

Problem: Macro call that should be transformed by with-wrap-attempt

Macro definition:
(defmacro with-wrap-attempt ((&optional format-control &rest format-args) wrappable-name &body body)
  `(call-with-wrap-attempt ,wrappable-name (lambda () ,@body) ,format-control (list ,@format-args)))

Macroexpansion:
(call-with-wrap-attempt name (lambda nil (define-foreign-type name (make-instance (quote foreign-alias) :name name :type (ensure-type type "alias of type ~S to ~S" type name)))) nil (list))
Generate a defmacro form that transforms code like this:
(define-alias-binding append appending)

Pattern to recognize: 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 append)) (quote appending)) (quote append))
Generate a defmacro form that transforms code like this:
(define-direct-binding over (var iterable &rest iterator-args) (let ((iterator (gensym "ITERATOR")) (next (gensym "NEXT")) (has-more (gensym "HAS-MORE")) (update (gensym "UPDATE")) (end (gensym "END"))) (values `(with-interleaving (let (,@(lambda-fiddle:extract-lambda-vars (enlist var)) (,iterator (make-iterator ,iterable ,@iterator-args)))) (multiple-value-bind (,next ,has-more ,update ,end) (step-functions ,iterator) (declare (ignore ,update))) (unwind-protect* (funcall ,end))) `(if (funcall ,has-more) (update ,var (funcall ,next)) (end-for)))))

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 over)) (lambda (var iterable &rest iterator-args) (let ((#:environment127 *environment*)) (declare (ignorable #:environment127)) (let ((iterator (gensym "ITERATOR")) (next (gensym "NEXT")) (has-more (gensym "HAS-MORE")) (update (gensym "UPDATE")) (end (gensym "END"))) (values (sb-int:quasiquote (with-interleaving (let (#S(sb-impl::comma :expr (lambda-fiddle:extract-lambda-vars (enlist var)) :kind 2) (#S(sb-impl::comma :expr iterator :kind 0) (make-iterator #S(sb-impl::comma :expr iterable :kind 0) #S(sb-impl::comma :expr iterator-args :kind 2))))) (multiple-value-bind (#S(sb-impl::comma :expr next :kind 0) #S(sb-impl::comma :expr has-more :kind 0) #S(sb-impl::comma :expr update :kind 0) #S(sb-impl::comma :expr end :kind 0)) (step-functions #S(sb-impl::comma :expr iterator :kind 0)) (declare (ignore #S(sb-impl::comma :expr update :kind 0)))) (unwind-protect* (funcall #S(sb-impl::comma :expr end :kind 0))))) (sb-int:quasiquote (if (funcall #S(sb-impl::comma :expr has-more :kind 0)) (update #S(sb-impl::comma :expr var :kind 0) (funcall #S(sb-impl::comma :expr next :kind 0))) (end-for)))))))) (quote over))
Create a Common Lisp macro for the following transformation. Before code:
(-> nil :key nil)

What needs to change: 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:
(define-case-aware-find-symbol find-pp-operator-name #:with-c-syntax.preprocess-operator)

What needs to change: Macro call that should be transformed by define-case-aware-find-symbol

Macro definition:
(defmacro define-case-aware-find-symbol
    (finder-function-name package-name
     &key (upcased-package-name (format nil "~A.~A" (string package-name) '#:UPCASED))
       (docstring
        (format nil "Find a symbol in `~A' package having a same NAME. If not found, returns `nil'."
                package-name)))
  `(eval-when (:compile-toplevel :load-toplevel :execute)
     (defpackage ,upcased-package-name
       (:use)
       (:intern
        ,@(loop for sym being the external-symbol of package-name
                collect (string-upcase (symbol-name sym)))))
     ,@(loop for sym being the external-symbol of package-name
             for upcased = (string-upcase (symbol-name sym))
             collect `(setf (symbol-value (find-symbol ,upcased ',upcased-package-name))
                            ',sym))
     (defun ,finder-function-name (string &optional (readtable-case (readtable-case *readtable*)))
       ,@(if docstring `(,docstring))
       (ecase readtable-case
         ((:upcase :invert)
          (if-let ((up-sym (find-symbol string ',upcased-package-name)))
            (symbol-value up-sym)))
         ((:downcase :preserve)
          (find-symbol string ',package-name))))))

Macroexpansion:
(eval-when (:compile-toplevel :load-toplevel :execute) (defpackage #A((41) base-char . "WITH-C-SYNTAX.PREPROCESS-OPERATOR.UPCASED") (:use) (:intern #A((7) base-char . "DEFINED") #A((7) base-char . "_PRAGMA"))) (setf (symbol-value (find-symbol #A((7) base-char . "DEFINED") (quote #A((41) base-char . "WITH-C-SYNTAX.PREPROCESS-OPERATOR.UPCASED")))) (quote with-c-syntax.preprocess-operator:|defined|)) (setf (symbol-value (find-symbol #A((7) base-char . "_PRAGMA") (quote #A((41) base-char . "WITH-C-SYNTAX.PREPROCESS-OPERATOR.UPCASED")))) (quote with-c-syntax.preprocess-operator:|_Pragma|)) (defun find-pp-operator-name (string &optional (readtable-case (readtable-case *readtable*))) #A((109) base-char . "Find a symbol in `WITH-C-SYNTAX.PREPROCESS-OPERATOR' package having a same NAME. If not found, returns `nil'.") (ecase readtable-case ((:upcase :invert) (if-let ((up-sym (find-symbol string (quote #A((41) base-char . "WITH-C-SYNTAX.PREPROCESS-OPERATOR.UPCASED"))))) (symbol-value up-sym))) ((:downcase :preserve) (find-symbol string (quote #:with-c-syntax.preprocess-operator))))))
You are a Common Lisp macro expert. Given this code pattern:
(*> (string "Mālum") (char #\,))

Write a macro that addresses: 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 (#:*>-offset203) (multiple-value-bind (#:*>-res204 #:*>-next205) (funcall (string "Mālum") #:*>-offset203) (if (ok? #:*>-res204) (funcall (char #\COMMA) #:*>-next205) (fail #:*>-next205))))
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:
(nil (:key nil))
You are a Common Lisp macro expert. Given this code pattern:
(with-yield (dolist (x data) (yield x (1+ x))))

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 (#:g143 #:g144) (with-call/cc (labels ((yield (&rest values) (setf #:g144 values) (let/cc k (setf #:g143 k)))) (dolist (x data) (yield x (1+ x))) (setf #:g143 nil))) (gen-lambda nil (cond ((null #:g143) (quote generator-stop)) (t (let ((current #:g144)) (funcall #:g143 nil) (apply (function values) (funcall values-handler current)))))))
Create a Common Lisp macro for the following transformation. Before code:
(->>
  nil
  (progn))

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

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

Macroexpansion:
(let* ((#:var185 nil) (#:var186 (progn #:var185)))
  #:var186)
Generate a defmacro form that transforms code like this:
(draw scene (:rect :x 0 :y 0 :height "100%" :width "100%") :fill (xlink-href pattern))

Pattern to recognize: 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 ((#:g154 (funcall (function make-svg-element) :rect (append (list :x 0 :y 0 :height "100%" :width "100%") (list :fill (xlink-href pattern)))))) (add-element scene #:g154) #:g154)
Write a Common Lisp macro to handle this code pattern:
(with-yield-binds (if *inside-insert-into* (apply #'format nil "(~{~A~^, ~}) VALUES (~{~A~^, ~})" (loop for (k v) on (set=-clause-args clause) by #'cddr collect (yield-arg k) into keys collect (yield-arg v) into values finally (return (list keys values)))) (format nil "SET ~{~A = ~A~^, ~}" (mapcar #'yield-arg (set=-clause-args clause)))))

Problem: 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 (if *inside-insert-into* (apply (function format) nil "(~{~A~^, ~}) VALUES (~{~A~^, ~})" (loop for (k v) on (set=-clause-args clause) by (function cddr) collect (yield-arg k) into keys collect (yield-arg v) into values finally (return (list keys values)))) (format nil "SET ~{~A = ~A~^, ~}" (mapcar (function yield-arg) (set=-clause-args clause))))) (loop for bind in (reverse *bind-values*) append bind)))
Create a Common Lisp macro for the following transformation. Before code:
(defpattern alist (&rest args) `(and ,@(loop for (key . value) in args collect `(assoc ,key ,value))))

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

Macro definition:
(defmacro defpattern (name lambda-list &body body)
  "Defines a derived pattern specifier named NAME. This is analogous
to DEFTYPE.

Examples:

    ;; Defines a LIST pattern.
    (defpattern list (&rest args)
      (when args
        `(cons ,(car args) (list ,@(cdr args)))))"
  `(eval-when (:compile-toplevel :load-toplevel :execute)
     (setf (pattern-expand-function ',name) (lambda ,lambda-list ,@body))))

Macroexpansion:
(%defpattern alist (quote &rest) (quote args) (lambda (quasiquote (and #S(sb-impl::comma :expr (loop for (key . value) in args collect (quasiquote (assoc #S(sb-impl::comma :expr key :kind 0) #S(sb-impl::comma :expr value :kind 0)))) :kind 2)))))
Define a macro that eliminates this repetitive pattern:
(mvlet nil
  :key
  nil)

Issue: Macro call that should be transformed by MVLET

Macro definition:
(defmacro MVLET ...)

Macroexpansion:
(progn :key nil)
Create a Common Lisp macro for the following transformation. Before code:
(cond-> 'some-name)

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

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

Macroexpansion:
(let* ((#:|cond134| 'some-name))
  #:|cond134|)
Create a Common Lisp macro for the following transformation. Before code:
(xor nil nil nil)

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

Macro definition:
(defmacro xor (&rest datums)
  "Evaluates its arguments one at a time, from left to right. If more than one
argument evaluates to a true value no further DATUMS are evaluated, and NIL is
returned as both primary and secondary value. If exactly one argument
evaluates to true, its value is returned as the primary value after all the
arguments have been evaluated, and T is returned as the secondary value. If no
arguments evaluate to true NIL is returned as primary, and T as secondary
value."
  (with-gensyms (xor tmp true)
    `(let (,tmp ,true)
       (declare (ignorable ,tmp))
       (block ,xor
         ,@(mapcar (lambda (datum)
                     `(if (setf ,tmp ,datum)
                          (if ,true
                              (return-from ,xor (values nil nil))
                              (setf ,true ,tmp))))
                   datums)
         (return-from ,xor (values ,true t))))))

Macroexpansion:
(let (#:tmp147 #:true148) (declare (ignorable #:tmp147)) (block #:xor146 (if (setf #:tmp147 nil) (if #:true148 (return-from #:xor146 (values nil nil)) (setf #:true148 #:tmp147))) (if (setf #:tmp147 nil) (if #:true148 (return-from #:xor146 (values nil nil)) (setf #:true148 #:tmp147))) (if (setf #:tmp147 nil) (if #:true148 (return-from #:xor146 (values nil nil)) (setf #:true148 #:tmp147))) (return-from #:xor146 (values #:true148 t))))
You are a Common Lisp macro expert. Given this code pattern:
(deferror "55006" object-in-use object-state-error)

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 object-in-use (object-state-error) nil) (setf (gethash "55006" *error-table*) (quote object-in-use)))
Create a Common Lisp macro for the following transformation. Before code:
(while nil
  (progn))

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

Macro definition:
(defmacro WHILE ...)

Macroexpansion:
(loop while nil
      do (progn (progn)))
You are a Common Lisp macro expert. Given this code pattern:
(defclass/a dbd-mysql (dbi-driver) ())

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

Macro definition:
(defmacro defclass/a (name superclasses slots &rest class-options)
  `(progn
     (defclass ,name ,superclasses ,slots ,@class-options)
     (deftype ,(intern (format nil "<~A>" (symbol-name name))) () ',name)
     (setf (find-class ',(intern (format nil "<~A>" (symbol-name name))))
           (find-class ',name))))

Macroexpansion:
(progn (defclass dbd-mysql (dbi-driver) nil) (deftype <dbd-mysql> nil (quote dbd-mysql)) (setf (find-class (quote <dbd-mysql>)) (find-class (quote dbd-mysql))))
Create a Common Lisp macro for the following transformation. Before code:
(with-connection (execute (create-table :user ((id :type :bigint :primary-key t) (name :type '(:varchar 32)) (email :type '(:varchar 255)) (status :type '(:varchar 20)) (created_at :type :datetime) (updated_at :type :datetime)))) (execute (create-table :tweet ((id :type :bigint :primary-key t) (user_id :type :bigint) (body :type :text) (created_at :type :datetime)))) (execute (insert-into :user (set= :id 1 :name "nitro_idiot" :email "e.arrows@gmail.com" :status "normal" :created_at (princ-to-string *now*)))) (execute (insert-into :tweet (set= :id 1 :user_id 1 :body "Hi." :created_at (princ-to-string *now*)))) (execute (insert-into :tweet (set= :id 2 :user_id 1 :body "Is it working?" :created_at (princ-to-string *now*)))))

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

Macro definition:
(defmacro with-connection (&body body)
  `(let ((*connection* (connect-cached :sqlite3 :database-name *db-path*)))
     ,@body))

Macroexpansion:
(let ((execute (connect (create-table :user ((id :type :bigint :primary-key t) (name :type (quote (:varchar 32))) (email :type (quote (:varchar 255))) (status :type (quote (:varchar 20))) (created_at :type :datetime) (updated_at :type :datetime)))))) (unwind-protect (progn (execute (create-table :tweet ((id :type :bigint :primary-key t) (user_id :type :bigint) (body :type :text) (created_at :type :datetime)))) (execute (insert-into :user (set= :id 1 :name "nitro_idiot" :email "e.arrows@gmail.com" :status "normal" :created_at (princ-to-string *now*)))) (execute (insert-into :tweet (set= :id 1 :user_id 1 :body "Hi." :created_at (princ-to-string *now*)))) (execute (insert-into :tweet (set= :id 2 :user_id 1 :body "Is it working?" :created_at (princ-to-string *now*))))) (disconnect execute)))
Define a macro that eliminates this repetitive pattern:
(gen-lambda-with-sticky-stop () (unless (cdr ldata) (get-next)) (setf ldata (cdr ldata)) (if (eq (car ldata) 'generator-stop) (sticky-stop) (apply #'values (ensure-list (car ldata)))))

Issue: Macro call that should be transformed by gen-lambda

Macro definition:
(defmacro gen-lambda (params &body rest)
  "Version of lambda that wraps the anonymous function in an instance of the basic-generator class. This allows the lambda to be identified as a generator by its type. Basic-generator objects are derived from funcallable-standard-class, therefore they can be called as functions."
  `(let ((values-handler (create-values-handler)))
     (declare (ignorable values-handler))
     (make-instance 
      'basic-generator 
      :function (lambda ,params ,@rest))))

Macroexpansion:
(make-instance (quote basic-generator) :function (sticky-stop-lambda nil (unless (cdr ldata) (get-next)) (setf ldata (cdr ldata)) (if (eq (car ldata) (quote generator-stop)) (sticky-stop) (apply (function values) (ensure-list (car ldata))))))
Write a Common Lisp macro to handle this code pattern:
(let-syntax common-lisp:nil)

Problem: Macro call that should be transformed by LET-SYNTAX

Macro definition:
(defmacro LET-SYNTAX ...)

Macroexpansion:
(common-lisp:progn)