You are a Common Lisp macro expert. Given this code pattern:
(def-iter iterator-cycle (base-iter stopped results tail) (cycle (iterable) "Continually yields the elements of its argument in order, starting over when the end is reached If the base iterator is empty, the result of iterator-cycle will be too ``` (cycle '(1 2 3 4)) ;; 1, 2, 3, 4, 1, 2, 3, 4, etc (iter-to-list (cycle '())) ;; nil ```" (init-state (base-iter (make-iterator iterable)))) (if stopped (values (prog1 (car tail) (setf tail (or (cdr tail) results))) t) (multiple-value-bind (next-item base-alive) (next base-iter) (if base-alive (values (progn (push next-item results) (car results)) t) (if results (progn (setf base-iter nil stopped t results (nreverse results) tail results) (self)) (values nil nil))))))

Write a macro that addresses: Macro call that should be transformed by def-iter

Macro definition:
(defmacro def-iter (name state-vars (constructor-name constructor-params &body constructor-body)
                    &body next-body)
  "An anaphoric convenience macro which can be re-implemented to change how iterators are
  structured. Exposes the local `init-state` macro within `constructor-body`

  If you don't want to-use this macro (which I totally understand) just write constructors for your
  iterators returning 0-argument closures representing the `next` function and you'll be fine. This
  macro just helped me get through a lot of waffling during development

  Parameters
  ----------
  `name` is a synbol naming the iterator's backing state. However it's actually
  ignored, since PICL doesn't currently expose iterators' backing state

  `state-vars` is a list of symbols naming the iterator's state variables.

  The `constructor-name/params/body` will be `defun`'d to create the user-facing constructor
  function. In `constructor-body`, the return value should be an iterator or a call to local
  `init-state` macro

  `next-body` The definition of the `next` function for this iterator, which will be run in a
   lexical environment consisting of the state vars

  Both `constructor-body` and `next-body` are defined in the lexical environment of the `def-iter`
  form, and as such can access any lexical bindings not shadowed by the `constructor-params` and
  `state-vars` respectively

  The local `init-state` macro.
  ----------------------------
  The arguments to `init-state` should be of the form `(statevar-symbol value-form)`or
  `statevar-symbol`. In the first case, the value of `value-form` will be used to initialize the
  state variable named by `symbol`. In the second case, `statevar-symbol` is also used as the
  corresponding `value-form`

  Example
  -------
  What follows is a sample implementation of the `count` iterator using this macro
  ```
  (def-iter ignored-backing-name (curr-val step)
    (count (start step)
      (init-state (curr-val start) step))
    (prog1 curr-val (incf curr-val step))))
  ````"

  (declare (ignore name))
  (alexandria:with-gensyms (next-fname)
    (let ((docstring "Function had no docstring, so this one was inserted"))
      (when (and (cdr constructor-body) (stringp (car constructor-body)))
        (setf docstring (car constructor-body)
              constructor-body (cdr constructor-body)))
      `(labels ((,next-fname (&key ,@state-vars)
                  (labels ((self () ,@next-body)) #'self)))
         (defun ,constructor-name ,constructor-params
           ,docstring
           (macrolet
               ((init-state (&rest argspecs)
                  (list 'apply '#',next-fname
                        (apply #'append
                               '(list )
                               (mapcar (lambda (aspec)
                                         (if (symbolp aspec)
                                             (list (alx:make-keyword aspec) aspec)
                                             (destructuring-bind (aname adef) aspec
                                               (list (alx:make-keyword aname) adef))))
                                       argspecs)))))
             ,@constructor-body))))))

Macroexpansion:
(labels ((#:next-fname134 (&key base-iter stopped results tail) (labels ((self nil (if stopped (values (prog1 (car tail) (setf tail (or (cdr tail) results))) t) (multiple-value-bind (next-item base-alive) (next base-iter) (if base-alive (values (progn (push next-item results) (car results)) t) (if results (progn (setf base-iter nil stopped t results (nreverse results) tail results) (self)) (values nil nil))))))) (function self)))) (defun cycle (iterable) "Continually yields the elements of its argument in order, starting over when the end is reached If the base iterator is empty, the result of iterator-cycle will be too ``` (cycle '(1 2 3 4)) ;; 1, 2, 3, 4, 1, 2, 3, 4, etc (iter-to-list (cycle '())) ;; nil ```" (macrolet ((init-state (&rest argspecs) (list (quote apply) (quote (function #:next-fname134)) (apply (function append) (quote (list)) (mapcar (lambda (aspec) (if (symbolp aspec) (list (alx:make-keyword aspec) aspec) (destructuring-bind (aname adef) aspec (list (alx:make-keyword aname) adef)))) argspecs))))) (init-state (base-iter (make-iterator iterable))))))