macro_name: DEFMACRO-CLAUSE

library: cl-lc

call_form: (defmacro-clause)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO DEFMACRO-CLAUSE:
  too few elements in
    ()
  to satisfy lambda list
    (CLAUSE-TEMPLATE &BODY BODY):
  at least 1 expected, but got 0


call_form: (defmacro-clause nil)

error: Iterate: empty clause template with body NIL


call_form:
(defmacro-clause nil
  nil)

error: Iterate: empty clause template with body (NIL)


call_form:
(defmacro-clause nil
  (progn))

error: Iterate: empty clause template with body ((PROGN))


call_form:
(defmacro-clause nil
  :key
  nil)

error: Iterate: empty clause template with body (KEY NIL)


call_form: (defmacro-clause 'lol-gen::some-name)

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defmacro clause-quote-2 (&key ((:quote lol-gen::some-name))))
  (iterate::install-clause-info '(quote) '(quote) 'clause-quote-2 nil nil)
  ''lol-gen::some-name)

status: verified


macro_name: MAX-OF

call_form: (max-of)

error:
Error while parsing arguments to DEFMACRO MAX-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (max-of nil)

expanded: (lc (nil) maximize)


call_form:
(max-of nil
  nil)

expanded: (lc (nil nil) maximize)


call_form:
(max-of nil
  (progn))

expanded: (lc (nil (progn)) maximize)


call_form:
(max-of nil
  :key
  nil)

expanded: (lc (nil :key nil) maximize)


call_form: (max-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) maximize)


macro_name: DEFCLAUSE-SEQUENCE

call_form: (defclause-sequence)

error:
Error while parsing arguments to DEFMACRO DEFCLAUSE-SEQUENCE:
  too few elements in
    ()
  to satisfy lambda list
    (ELEMENT-NAME INDEX-NAME &KEY ACCESS-FN SIZE-FN ELEMENT-TYPE SEQUENCE-TYPE
     ELEMENT-DOC-STRING INDEX-DOC-STRING):
  at least 2 expected, but got 0


call_form: (defclause-sequence nil)

error:
Error while parsing arguments to DEFMACRO DEFCLAUSE-SEQUENCE:
  too few elements in
    (NIL)
  to satisfy lambda list
    (ELEMENT-NAME INDEX-NAME &KEY ACCESS-FN SIZE-FN ELEMENT-TYPE SEQUENCE-TYPE
     ELEMENT-DOC-STRING INDEX-DOC-STRING):
  at least 2 expected, but got 1


call_form: (defclause-sequence nil nil)

expanded: (progn nil nil)


call_form: (defclause-sequence nil (progn))

error:
The value
  (PROGN)
is not of type
  SYMBOL
when binding SYMBOL


call_form: (defclause-sequence nil :key nil)

error:
Error while parsing arguments to DEFCLAUSE-SEQUENCE DEFMACRO:
  odd number of elements in keyword/value list: (NIL)


error:
Error while parsing arguments to DEFMACRO DEFCLAUSE-SEQUENCE:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (ELEMENT-NAME INDEX-NAME &KEY ACCESS-FN SIZE-FN ELEMENT-TYPE SEQUENCE-TYPE
     ELEMENT-DOC-STRING INDEX-DOC-STRING):
  at least 2 expected, but got 1


macro_name: NONE-OF

call_form: (none-of)

error:
Error while parsing arguments to DEFMACRO NONE-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (none-of nil)

expanded: (lc (nil) never)


call_form:
(none-of nil
  nil)

expanded: (lc (nil nil) never)


call_form:
(none-of nil
  (progn))

expanded: (lc (nil (progn)) never)


call_form:
(none-of nil
  :key
  nil)

expanded: (lc (nil :key nil) never)


call_form: (none-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) never)


macro_name: LEAVE

call_form: (leave)

error: The variable ITERATE::*LOOP-NAME* is unbound.


call_form: (leave nil)


call_form: (leave nil nil)

error:
Error while parsing arguments to DEFMACRO LEAVE:
  too many elements in
    (NIL NIL)
  to satisfy lambda list
    (&OPTIONAL VALUE):
  between 0 and 1 expected, but got 2


call_form: (leave nil (progn))

error:
Error while parsing arguments to DEFMACRO LEAVE:
  too many elements in
    (NIL (PROGN))
  to satisfy lambda list
    (&OPTIONAL VALUE):
  between 0 and 1 expected, but got 2


call_form: (leave nil :key nil)

error:
Error while parsing arguments to DEFMACRO LEAVE:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (&OPTIONAL VALUE):
  between 0 and 1 expected, but got 3


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


macro_name: DEFSYNONYM

call_form: (defsynonym)

error:
Error while parsing arguments to DEFMACRO DEFSYNONYM:
  too few elements in
    ()
  to satisfy lambda list
    (SYN WORD):
  exactly 2 expected, but got 0


call_form: (defsynonym nil)

error:
Error while parsing arguments to DEFMACRO DEFSYNONYM:
  too few elements in
    (NIL)
  to satisfy lambda list
    (SYN WORD):
  exactly 2 expected, but got 1


call_form: (defsynonym nil nil)

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (setf (get 'nil 'iterate::synonym) 'nil))


call_form: (defsynonym nil (progn))

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (setf (get 'nil 'iterate::synonym) '(progn)))


call_form: (defsynonym nil :key nil)

error:
Error while parsing arguments to DEFMACRO DEFSYNONYM:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (SYN WORD):
  exactly 2 expected, but got 3


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

error:
Error while parsing arguments to DEFMACRO DEFSYNONYM:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (SYN WORD):
  exactly 2 expected, but got 1


macro_name: NEXT-ITERATION

call_form: (next-iteration)

error: The variable ITERATE::*LOOP-STEP* is unbound.


call_form: (next-iteration nil)

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


call_form: (next-iteration nil nil)

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


call_form: (next-iteration nil (progn))

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


call_form: (next-iteration nil :key nil)

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


call_form: (next-iteration 'lol-gen::some-name)

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


macro_name: DICT-OF

call_form: (dict-of)

error:
Error while parsing arguments to DEFMACRO DICT-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &REST EXPS):
  at least 1 expected, but got 0


call_form: (dict-of nil)

expanded:
(let ((#:dict128 (make-hash-table :test 'equal)))
  (do-for nil
    (multiple-value-call
        (lambda (#:k129 #:v130) (setf (gethash #:k129 #:dict128) #:v130))
      nil))
  #:dict128)


call_form: (dict-of nil nil)

expanded:
(let ((#:dict131 (make-hash-table :test 'equal)))
  (do-for (nil)
    (multiple-value-call
        (lambda (#:k132 #:v133) (setf (gethash #:k132 #:dict131) #:v133))
      nil))
  #:dict131)


call_form: (dict-of nil (progn))

expanded:
(let ((#:dict134 (make-hash-table :test 'equal)))
  (do-for ((progn))
    (multiple-value-call
        (lambda (#:k135 #:v136) (setf (gethash #:k135 #:dict134) #:v136))
      nil))
  #:dict134)


call_form: (dict-of nil :key nil)

expanded:
(let ((#:dict137 (make-hash-table :test 'equal)))
  (do-for (:key nil)
    (multiple-value-call
        (lambda (#:k138 #:v139) (setf (gethash #:k138 #:dict137) #:v139))
      nil))
  #:dict137)


call_form: (dict-of 'lol-gen::some-name)

expanded:
(let ((#:dict140 (make-hash-table :test 'equal)))
  (do-for nil
    (multiple-value-call
        (lambda (#:k141 #:v142) (setf (gethash #:k141 #:dict140) #:v142))
      'lol-gen::some-name))
  #:dict140)


macro_name: SUM-OF

call_form: (sum-of)

error:
Error while parsing arguments to DEFMACRO SUM-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (sum-of nil)

expanded: (lc (nil) sum)


call_form:
(sum-of nil
  nil)

expanded: (lc (nil nil) sum)


call_form:
(sum-of nil
  (progn))

expanded: (lc (nil (progn)) sum)


call_form:
(sum-of nil
  :key
  nil)

expanded: (lc (nil :key nil) sum)


call_form: (sum-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) sum)


macro_name: TERMINATE

call_form: (terminate)

expanded: (finish)


call_form: (terminate nil)

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


call_form: (terminate nil nil)

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


call_form: (terminate nil (progn))

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


call_form: (terminate nil :key nil)

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


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

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


macro_name: MIN-OF

call_form: (min-of)

error:
Error while parsing arguments to DEFMACRO MIN-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (min-of nil)

expanded: (lc (nil) minimize)


call_form:
(min-of nil
  nil)

expanded: (lc (nil nil) minimize)


call_form:
(min-of nil
  (progn))

expanded: (lc (nil (progn)) minimize)


call_form:
(min-of nil
  :key
  nil)

expanded: (lc (nil :key nil) minimize)


call_form: (min-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) minimize)


macro_name: FINISH

call_form: (finish)

error: The variable ITERATE::*LOOP-END* is unbound.


call_form: (finish nil)

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


call_form: (finish nil nil)

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


call_form: (finish nil (progn))

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


call_form: (finish nil :key nil)

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


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

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


macro_name: LIST-OF

call_form: (list-of)

error:
Error while parsing arguments to DEFMACRO LIST-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (list-of nil)

expanded: (lc (nil) collect)


call_form:
(list-of nil
  nil)

expanded: (lc (nil nil) collect)


call_form:
(list-of nil
  (progn))

expanded: (lc (nil (progn)) collect)


call_form:
(list-of nil
  :key
  nil)

expanded: (lc (nil :key nil) collect)


call_form: (list-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) collect)


macro_name: ANY-OF

call_form: (any-of)

error:
Error while parsing arguments to DEFMACRO ANY-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (any-of nil)

expanded: (lc (nil) thereis)


call_form:
(any-of nil
  nil)

expanded: (lc (nil nil) thereis)


call_form:
(any-of nil
  (progn))

expanded: (lc (nil (progn)) thereis)


call_form:
(any-of nil
  :key
  nil)

expanded: (lc (nil :key nil) thereis)


call_form: (any-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) thereis)


macro_name: COUNT-OF

call_form: (count-of)

error:
Error while parsing arguments to DEFMACRO COUNT-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (count-of nil)

expanded: (lc (nil) count)


call_form:
(count-of nil
  nil)

expanded: (lc (nil nil) count)


call_form:
(count-of nil
  (progn))

expanded: (lc (nil (progn)) count)


call_form:
(count-of nil
  :key
  nil)

expanded: (lc (nil :key nil) count)


call_form: (count-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) count)


macro_name: DEFMACRO-DRIVER

call_form: (defmacro-driver)

error:
Error while parsing arguments to DEFMACRO DEFMACRO-DRIVER:
  too few elements in
    ()
  to satisfy lambda list
    (CLAUSE-TEMPLATE &BODY BODY):
  at least 1 expected, but got 0


call_form: (defmacro-driver nil)

error: Iterate: empty clause template with body NIL


call_form:
(defmacro-driver nil
  nil)

error: Iterate: empty clause template with body (NIL)


call_form:
(defmacro-driver nil
  (progn))

error: Iterate: empty clause template with body ((PROGN))


call_form:
(defmacro-driver nil
  :key
  nil)

error: Iterate: empty clause template with body (KEY NIL)


call_form: (defmacro-driver 'lol-gen::some-name)

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defmacro clause-quote-3 (&key ((:quote lol-gen::some-name)) generate))
  (iterate::install-clause-info '(quote) '(quote) 'clause-quote-3 nil t)
  ''lol-gen::some-name)


macro_name: VECT-OF

call_form: (vect-of)

error:
Error while parsing arguments to DEFMACRO VECT-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &REST EXPS):
  at least 1 expected, but got 0


call_form: (vect-of nil)

expanded:
(let ((#:vect143 (make-array 10 :adjustable t :fill-pointer 0)))
  (do-for nil
    (vector-push-extend nil #:vect143))
  #:vect143)


call_form: (vect-of nil nil)

expanded:
(let ((#:vect144 (make-array 10 :adjustable t :fill-pointer 0)))
  (do-for (nil)
    (vector-push-extend nil #:vect144))
  #:vect144)


call_form: (vect-of nil (progn))

expanded:
(let ((#:vect145 (make-array 10 :adjustable t :fill-pointer 0)))
  (do-for ((progn))
    (vector-push-extend nil #:vect145))
  #:vect145)


call_form: (vect-of nil :key nil)

expanded:
(let ((#:vect146 (make-array 10 :adjustable t :fill-pointer 0)))
  (do-for (:key nil)
    (vector-push-extend nil #:vect146))
  #:vect146)


call_form: (vect-of 'lol-gen::some-name)

expanded:
(let ((#:vect147 (make-array 10 :adjustable t :fill-pointer 0)))
  (do-for nil
    (vector-push-extend 'lol-gen::some-name #:vect147))
  #:vect147)


macro_name: ITER

call_form: (iter)

expanded:
(let* ()
  (block nil
    (block nil
      (tagbody (progn) loop-top-nil (progn) (progn) (go loop-top-nil) (progn))
      nil)))


call_form:
(iter
  nil)


call_form:
(iter
  nil
  nil)

expanded:
(let* ()
  (block nil
    (block nil
      (tagbody
        (progn)
       loop-top-nil
        (progn nil)
        (progn)
        (go loop-top-nil)
        (progn))
      nil)))


call_form:
(iter
  nil
  (progn))


call_form:
(iter
  nil
  :key
  nil)

expanded:
(let* ()
  (block nil
    (block nil
      (tagbody
        (progn)
       loop-top-nil
        (progn :key nil)
        (progn)
        (go loop-top-nil)
        (progn))
      nil)))


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

expanded:
(let* ()
  (block nil
    (block #:iterate148
      (tagbody
        (progn)
       loop-top-nil
        (progn 'lol-gen::some-name)
        (progn)
        (go loop-top-nil)
        (progn))
      nil)))


macro_name: PRODUCT-OF

call_form: (product-of)

error:
Error while parsing arguments to DEFMACRO PRODUCT-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (product-of nil)

expanded: (lc (nil) multiply)


call_form:
(product-of nil
  nil)

expanded: (lc (nil nil) multiply)


call_form:
(product-of nil
  (progn))

expanded: (lc (nil (progn)) multiply)


call_form:
(product-of nil
  :key
  nil)

expanded: (lc (nil :key nil) multiply)


call_form: (product-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) multiply)


macro_name: DSETQ

call_form: (dsetq)

error:
Error while parsing arguments to DEFMACRO DSETQ:
  too few elements in
    ()
  to satisfy lambda list
    (TEMPLATE VALUE):
  exactly 2 expected, but got 0


call_form: (dsetq nil)

error:
Error while parsing arguments to DEFMACRO DSETQ:
  too few elements in
    (NIL)
  to satisfy lambda list
    (TEMPLATE VALUE):
  exactly 2 expected, but got 1


call_form: (dsetq nil nil)

error: DSETQ: Can't bind to nil


call_form: (dsetq nil (progn))


call_form: (dsetq nil :key nil)

error:
Error while parsing arguments to DEFMACRO DSETQ:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (TEMPLATE VALUE):
  exactly 2 expected, but got 3


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

error:
Error while parsing arguments to DEFMACRO DSETQ:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (TEMPLATE VALUE):
  exactly 2 expected, but got 1


macro_name: DO-FOR

call_form: (do-for)

error:
Error while parsing arguments to DEFMACRO DO-FOR:
  too few elements in
    ()
  to satisfy lambda list
    ((&REST QS) &BODY HEAD):
  at least 1 expected, but got 0


call_form: (do-for nil)

expanded: (block nil (lc ((block nil (tagbody (return (progn))))) progn))


call_form:
(do-for nil
  nil)

expanded: (block nil (lc ((block nil (tagbody (return (progn nil))))) progn))


call_form:
(do-for nil
  (progn))

expanded: (block nil (lc ((block nil (tagbody (return (progn (progn)))))) progn))


call_form:
(do-for nil
  :key
  nil)

expanded: (block nil (lc ((block nil (tagbody (return (progn :key nil))))) progn))


call_form: (do-for 'lol-gen::some-name)

expanded:
(block nil
  (lc ((block nil (tagbody (return (progn)))) quote lol-gen::some-name) progn))


macro_name: ITERATE

call_form:
(iterate
  nil)

expanded:
(iter
  nil)


call_form:
(iterate
  nil
  nil)

expanded:
(iter
  nil
  nil)


call_form:
(iterate
  nil
  (progn))

expanded:
(iter
  nil
  (progn))


call_form:
(iterate
  nil
  :key
  nil)

expanded:
(iter
  nil
  :key
  nil)


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

expanded:
(iter
  'lol-gen::some-name)


macro_name: ALL-OF

call_form: (all-of)

error:
Error while parsing arguments to DEFMACRO ALL-OF:
  too few elements in
    ()
  to satisfy lambda list
    (EXP &BODY EXPS):
  at least 1 expected, but got 0


call_form: (all-of nil)

expanded: (lc (nil) always)


call_form:
(all-of nil
  nil)

expanded: (lc (nil nil) always)


call_form:
(all-of nil
  (progn))

expanded: (lc (nil (progn)) always)


call_form:
(all-of nil
  :key
  nil)

expanded: (lc (nil :key nil) always)


call_form: (all-of 'lol-gen::some-name)

expanded: (lc ('lol-gen::some-name) always)