macro_name: INEXT-OR-ERROR

library: cl-itertools

call_form: (inext-or-error)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO INEXT-OR-ERROR:
  too few elements in
    ()
  to satisfy lambda list
    (ITER-VAR &OPTIONAL (ARG)):
  between 1 and 2 expected, but got 0


call_form: (inext-or-error nil)

expanded:
(let ((vals (multiple-value-list (funcall (i-coro nil) nil))))
  (if (not vals)
      (error 'stop-iteration)
      (values (car vals) t)))

status: verified


call_form: (inext-or-error nil nil)


call_form: (inext-or-error nil (progn))

expanded:
(let ((vals (multiple-value-list (funcall (i-coro nil) (progn)))))
  (if (not vals)
      (error 'stop-iteration)
      (values (car vals) t)))


call_form: (inext-or-error nil :key nil)

error:
Error while parsing arguments to DEFMACRO INEXT-OR-ERROR:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ITER-VAR &OPTIONAL (ARG)):
  between 1 and 2 expected, but got 3


call_form: (inext-or-error 'lol-gen::some-name)

expanded:
(let ((vals (multiple-value-list (funcall (i-coro 'lol-gen::some-name) nil))))
  (if (not vals)
      (error 'stop-iteration)
      (values (car vals) t)))


macro_name: INEXT

call_form: (inext)

error:
Error while parsing arguments to DEFMACRO INEXT:
  too few elements in
    ()
  to satisfy lambda list
    (ITER-VAR &OPTIONAL (ARG)):
  between 1 and 2 expected, but got 0


call_form: (inext nil)

expanded:
(let ((vals (multiple-value-list (funcall (i-coro nil) nil))))
  (if (not vals)
      (coexit!)
      (car vals)))


call_form: (inext nil nil)


call_form: (inext nil (progn))

expanded:
(let ((vals (multiple-value-list (funcall (i-coro nil) (progn)))))
  (if (not vals)
      (coexit!)
      (car vals)))


call_form: (inext nil :key nil)

error:
Error while parsing arguments to DEFMACRO INEXT:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ITER-VAR &OPTIONAL (ARG)):
  between 1 and 2 expected, but got 3


call_form: (inext 'lol-gen::some-name)

expanded:
(let ((vals (multiple-value-list (funcall (i-coro 'lol-gen::some-name) nil))))
  (if (not vals)
      (coexit!)
      (car vals)))


macro_name: DEF-LAUNCHED-ITER

call_form: (def-launched-iter)

error:
Error while parsing arguments to DEFMACRO DEF-LAUNCHED-ITER:
  too few elements in
    ()
  to satisfy lambda list
    (NAME ARGS &BODY BODY):
  at least 2 expected, but got 0


call_form: (def-launched-iter nil)

error:
Error while parsing arguments to DEFMACRO DEF-LAUNCHED-ITER:
  too few elements in
    (NIL)
  to satisfy lambda list
    (NAME ARGS &BODY BODY):
  at least 2 expected, but got 1


call_form:
(def-launched-iter nil
    nil)

expanded:
(defun nil ()
  (let ((it (make-instance 'iterator :coro (lambda-coro))))
    (inext-or-error it)
    it))


call_form:
(def-launched-iter nil
    (progn))

expanded:
(defun nil (progn)
  (let ((it (make-instance 'iterator :coro (lambda-coro))))
    (inext-or-error it)
    it))


call_form:
(def-launched-iter nil
    :key
  nil)

expanded:
(defun nil :key
  (let ((it
         (make-instance 'iterator :coro
                        (lambda-coro
                          nil))))
    (inext-or-error it)
    it))


call_form: (def-launched-iter 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEF-LAUNCHED-ITER:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (NAME ARGS &BODY BODY):
  at least 2 expected, but got 1


macro_name: COEXIT!

call_form: (coexit!)

expanded: (coexit (values))


call_form: (coexit! nil)

error:
Error while parsing arguments to DEFMACRO COEXIT!:
  too many elements in
    (NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


call_form: (coexit! nil nil)

error:
Error while parsing arguments to DEFMACRO COEXIT!:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


call_form: (coexit! nil (progn))

error:
Error while parsing arguments to DEFMACRO COEXIT!:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    ():
  exactly 0 expected, but got 2


call_form: (coexit! nil :key nil)

error:
Error while parsing arguments to DEFMACRO COEXIT!:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 3


call_form: (coexit! 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO COEXIT!:
  too many elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    ():
  exactly 0 expected, but got 1


macro_name: LAMBDA-CORO

call_form: (lambda-coro)

expanded:
(progn
 (defcoroutine #:name129
     (#:arg130)
   (macrolet ((yield (form)
                (let ((g!-it (gensym "IT")))
                  `(progn
                    (let ((,g!-it ,form))
                      (cl-coroutine:yield ,g!-it))
                    ,'#:arg130)))
              (last-yield-value ()
                '#:arg130))
     (coexit!)))
 (make-coroutine '#:name129))


call_form:
(lambda-coro
  nil)

expanded:
(progn
 (defcoroutine #:name131
     (#:arg132)
   (macrolet ((yield (form)
                (let ((g!-it (gensym "IT")))
                  `(progn
                    (let ((,g!-it ,form))
                      (cl-coroutine:yield ,g!-it))
                    ,'#:arg132)))
              (last-yield-value ()
                '#:arg132))
     nil
     (coexit!)))
 (make-coroutine '#:name131))


call_form:
(lambda-coro
  nil
  nil)

expanded:
(progn
 (defcoroutine #:name133
     (#:arg134)
   (macrolet ((yield (form)
                (let ((g!-it (gensym "IT")))
                  `(progn
                    (let ((,g!-it ,form))
                      (cl-coroutine:yield ,g!-it))
                    ,'#:arg134)))
              (last-yield-value ()
                '#:arg134))
     nil
     nil
     (coexit!)))
 (make-coroutine '#:name133))


call_form:
(lambda-coro
  nil
  (progn))

expanded:
(progn
 (defcoroutine #:name135
     (#:arg136)
   (macrolet ((yield (form)
                (let ((g!-it (gensym "IT")))
                  `(progn
                    (let ((,g!-it ,form))
                      (cl-coroutine:yield ,g!-it))
                    ,'#:arg136)))
              (last-yield-value ()
                '#:arg136))
     nil
     (progn)
     (coexit!)))
 (make-coroutine '#:name135))


call_form:
(lambda-coro
  nil
  :key
  nil)

expanded:
(progn
 (defcoroutine #:name137
     (#:arg138)
   (macrolet ((yield (form)
                (let ((g!-it (gensym "IT")))
                  `(progn
                    (let ((,g!-it ,form))
                      (cl-coroutine:yield ,g!-it))
                    ,'#:arg138)))
              (last-yield-value ()
                '#:arg138))
     nil
     :key
     nil
     (coexit!)))
 (make-coroutine '#:name137))


call_form:
(lambda-coro
  'lol-gen::some-name)

expanded:
(progn
 (defcoroutine #:name139
     (#:arg140)
   (macrolet ((yield (form)
                (let ((g!-it (gensym "IT")))
                  `(progn
                    (let ((,g!-it ,form))
                      (cl-coroutine:yield ,g!-it))
                    ,'#:arg140)))
              (last-yield-value ()
                '#:arg140))
     'lol-gen::some-name
     (coexit!)))
 (make-coroutine '#:name139))


macro_name: INEXT-NOEXIT

call_form: (inext-noexit)

error:
Error while parsing arguments to DEFMACRO INEXT-NOEXIT:
  too few elements in
    ()
  to satisfy lambda list
    (ITER-VAR &OPTIONAL (ARG)):
  between 1 and 2 expected, but got 0


call_form: (inext-noexit nil)

expanded:
(let ((vals (multiple-value-list (funcall (i-coro nil) nil))))
  (if (not vals)
      (values nil nil)
      (values (car vals) t)))


call_form: (inext-noexit nil nil)


call_form: (inext-noexit nil (progn))

expanded:
(let ((vals (multiple-value-list (funcall (i-coro nil) (progn)))))
  (if (not vals)
      (values nil nil)
      (values (car vals) t)))


call_form: (inext-noexit nil :key nil)

error:
Error while parsing arguments to DEFMACRO INEXT-NOEXIT:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (ITER-VAR &OPTIONAL (ARG)):
  between 1 and 2 expected, but got 3


call_form: (inext-noexit 'lol-gen::some-name)

expanded:
(let ((vals (multiple-value-list (funcall (i-coro 'lol-gen::some-name) nil))))
  (if (not vals)
      (values nil nil)
      (values (car vals) t)))


macro_name: DEFITER

call_form: (defiter)

error:
Error while parsing arguments to DEFMACRO DEFITER:
  too few elements in
    ()
  to satisfy lambda list
    (NAME ARGS &BODY BODY):
  at least 2 expected, but got 0


call_form: (defiter nil)

error:
Error while parsing arguments to DEFMACRO DEFITER:
  too few elements in
    (NIL)
  to satisfy lambda list
    (NAME ARGS &BODY BODY):
  at least 2 expected, but got 1


call_form:
(defiter nil
    nil)

expanded: (defun nil () (make-instance 'iterator :coro (lambda-coro)))


call_form:
(defiter nil
    (progn))

expanded: (defun nil (progn) (make-instance 'iterator :coro (lambda-coro)))


call_form:
(defiter nil
    :key
  nil)

expanded:
(defun nil :key
  (make-instance 'iterator :coro
                 (lambda-coro
                   nil)))


call_form: (defiter 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO DEFITER:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (NAME ARGS &BODY BODY):
  at least 2 expected, but got 1