macro_name: SUNLESS

library: anaphora

call_form: (sunless)

status: expansion-error

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


call_form: (sunless nil)

expanded: (symbolic unless nil)

status: verified


call_form:
(sunless nil
  nil)

expanded: (symbolic unless nil nil)


call_form:
(sunless nil
  (progn))

expanded: (symbolic unless nil (progn))


call_form:
(sunless nil
  :key
  nil)

expanded: (symbolic unless nil :key nil)


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

expanded: (symbolic unless 'lol-gen::some-name)


macro_name: AAND

call_form: (aand)

error:
Error while parsing arguments to DEFMACRO AAND:
  too few elements in
    ()
  to satisfy lambda list
    (FIRST &REST REST):
  at least 1 expected, but got 0


call_form: (aand nil)

expanded:
(anaphoric and
    nil)


call_form: (aand nil nil)

expanded:
(anaphoric and
    nil
  nil)


call_form: (aand nil (progn))

expanded:
(anaphoric and
    nil
  (progn))


call_form: (aand nil :key nil)

expanded:
(anaphoric and
    nil
  :key
  nil)


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

expanded:
(anaphoric and
    'lol-gen::some-name)


macro_name: STYPECASE

call_form: (stypecase)

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


call_form: (stypecase nil)

expanded: (symbolic typecase nil)


call_form:
(stypecase nil
  nil)

expanded: (symbolic typecase nil nil)


call_form:
(stypecase nil
  (progn))

expanded: (symbolic typecase nil (progn))


call_form:
(stypecase nil
  :key
  nil)

expanded: (symbolic typecase nil :key nil)


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

expanded: (symbolic typecase 'lol-gen::some-name)


macro_name: SCCASE

call_form: (sccase)

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


call_form: (sccase nil)

expanded: (symbolic ccase nil)


call_form:
(sccase nil
  nil)

expanded: (symbolic ccase nil nil)


call_form:
(sccase nil
  (progn))

expanded: (symbolic ccase nil (progn))


call_form:
(sccase nil
  :key
  nil)

expanded: (symbolic ccase nil :key nil)


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

expanded: (symbolic ccase 'lol-gen::some-name)


macro_name: ACASE

call_form: (acase)

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


call_form: (acase nil)

expanded:
(anaphoric case
    nil)


call_form:
(acase nil
  nil)

expanded:
(anaphoric case
    nil
  nil)


call_form:
(acase nil
  (progn))

expanded:
(anaphoric case
    nil
  (progn))


call_form:
(acase nil
  :key
  nil)

expanded:
(anaphoric case
    nil
  :key
  nil)


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

expanded:
(anaphoric case
    'lol-gen::some-name)


macro_name: SOR

call_form: (sor)

error:
Error while parsing arguments to DEFMACRO SOR:
  too few elements in
    ()
  to satisfy lambda list
    (FIRST &REST REST):
  at least 1 expected, but got 0


call_form: (sor nil)

expanded: (symbolic or nil)


call_form: (sor nil nil)

expanded: (symbolic or nil nil)


call_form: (sor nil (progn))

expanded: (symbolic or nil (progn))


call_form: (sor nil :key nil)

expanded: (symbolic or nil :key nil)


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

expanded: (symbolic or 'lol-gen::some-name)


macro_name: AWHEN

call_form: (awhen)

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


call_form: (awhen nil)

expanded:
(anaphoric when
    nil)


call_form:
(awhen nil
  nil)

expanded:
(anaphoric when
    nil
  nil)


call_form:
(awhen nil
  (progn))

expanded:
(anaphoric when
    nil
  (progn))


call_form:
(awhen nil
  :key
  nil)

expanded:
(anaphoric when
    nil
  :key
  nil)


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

expanded:
(anaphoric when
    'lol-gen::some-name)


macro_name: ACCASE

call_form: (accase)

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


call_form: (accase nil)

expanded:
(anaphoric ccase
    nil)


call_form:
(accase nil
  nil)

expanded:
(anaphoric ccase
    nil
  nil)


call_form:
(accase nil
  (progn))

expanded:
(anaphoric ccase
    nil
  (progn))


call_form:
(accase nil
  :key
  nil)

expanded:
(anaphoric ccase
    nil
  :key
  nil)


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

expanded:
(anaphoric ccase
    'lol-gen::some-name)


macro_name: AETYPECASE

call_form: (aetypecase)

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


call_form: (aetypecase nil)

expanded:
(anaphoric etypecase
    nil)


call_form:
(aetypecase nil
  nil)

expanded:
(anaphoric etypecase
    nil
  nil)


call_form:
(aetypecase nil
  (progn))

expanded:
(anaphoric etypecase
    nil
  (progn))


call_form:
(aetypecase nil
  :key
  nil)

expanded:
(anaphoric etypecase
    nil
  :key
  nil)


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

expanded:
(anaphoric etypecase
    'lol-gen::some-name)


macro_name: ATYPECASE

call_form: (atypecase)

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


call_form: (atypecase nil)

expanded:
(anaphoric typecase
    nil)


call_form:
(atypecase nil
  nil)

expanded:
(anaphoric typecase
    nil
  nil)


call_form:
(atypecase nil
  (progn))

expanded:
(anaphoric typecase
    nil
  (progn))


call_form:
(atypecase nil
  :key
  nil)

expanded:
(anaphoric typecase
    nil
  :key
  nil)


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

expanded:
(anaphoric typecase
    'lol-gen::some-name)


macro_name: SCTYPECASE

call_form: (sctypecase)

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


call_form: (sctypecase nil)

expanded: (symbolic ctypecase nil)


call_form:
(sctypecase nil
  nil)

expanded: (symbolic ctypecase nil nil)


call_form:
(sctypecase nil
  (progn))

expanded: (symbolic ctypecase nil (progn))


call_form:
(sctypecase nil
  :key
  nil)

expanded: (symbolic ctypecase nil :key nil)


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


macro_name: SIF

call_form: (sif)

error:
Error while parsing arguments to DEFMACRO SIF:
  too few elements in
    ()
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 0


call_form: (sif nil)

error:
Error while parsing arguments to DEFMACRO SIF:
  too few elements in
    (NIL)
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 1


call_form: (sif nil nil)

expanded: (symbolic if nil nil nil)


call_form: (sif nil (progn))

expanded: (symbolic if nil (progn) nil)


call_form: (sif nil :key nil)

expanded: (symbolic if nil :key nil)


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

error:
Error while parsing arguments to DEFMACRO SIF:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 1


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


call_form: (aprog1 nil)

expanded:
(anaphoric prog1
    nil)


call_form:
(aprog1 nil
  nil)

expanded:
(anaphoric prog1
    nil
  nil)


call_form:
(aprog1 nil
  (progn))

expanded:
(anaphoric prog1
    nil
  (progn))


call_form:
(aprog1 nil
  :key
  nil)

expanded:
(anaphoric prog1
    nil
  :key
  nil)


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

expanded:
(anaphoric prog1
    'lol-gen::some-name)


macro_name: ALAMBDA

call_form: (alambda)

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


call_form: (alambda nil)

expanded:
(labels ((self ()
           ))
  #'self)


call_form:
(alambda nil
  nil)

expanded:
(labels ((self ()
           nil))
  #'self)


call_form:
(alambda nil
  (progn))

expanded:
(labels ((self ()
           (progn)))
  #'self)


call_form:
(alambda nil
  :key
  nil)

expanded:
(labels ((self ()
           :key
           nil))
  #'self)


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

expanded:
(labels ((self (quote lol-gen::some-name)
           ))
  #'self)


macro_name: ALET

call_form: (alet)

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


call_form: (alet nil)

expanded:
(anaphoric ignore-first
    nil
  (progn))


call_form:
(alet nil
  nil)

expanded:
(anaphoric ignore-first
    nil
  (progn nil))


call_form:
(alet nil
  (progn))

expanded:
(anaphoric ignore-first
    nil
  (progn (progn)))


call_form:
(alet nil
  :key
  nil)

expanded:
(anaphoric ignore-first
    nil
  (progn :key nil))


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

expanded:
(anaphoric ignore-first
    'lol-gen::some-name
  (progn))


macro_name: SECASE

call_form: (secase)

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


call_form: (secase nil)

expanded: (symbolic ecase nil)


call_form:
(secase nil
  nil)

expanded: (symbolic ecase nil nil)


call_form:
(secase nil
  (progn))

expanded: (symbolic ecase nil (progn))


call_form:
(secase nil
  :key
  nil)

expanded: (symbolic ecase nil :key nil)


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

expanded: (symbolic ecase 'lol-gen::some-name)


macro_name: SCASE

call_form: (scase)

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


call_form: (scase nil)

expanded: (symbolic case nil)


call_form:
(scase nil
  nil)

expanded: (symbolic case nil nil)


call_form:
(scase nil
  (progn))

expanded: (symbolic case nil (progn))


call_form:
(scase nil
  :key
  nil)

expanded: (symbolic case nil :key nil)


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

expanded: (symbolic case 'lol-gen::some-name)


macro_name: SLET

call_form: (slet)

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


call_form: (slet nil)

expanded: (symbolic ignore-first nil (progn))


call_form:
(slet nil
  nil)

expanded: (symbolic ignore-first nil (progn nil))


call_form:
(slet nil
  (progn))

expanded: (symbolic ignore-first nil (progn (progn)))


call_form:
(slet nil
  :key
  nil)

expanded: (symbolic ignore-first nil (progn :key nil))


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

expanded: (symbolic ignore-first 'lol-gen::some-name (progn))


macro_name: ASIF

call_form: (asif)

error:
Error while parsing arguments to DEFMACRO ASIF:
  too few elements in
    ()
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 0


call_form: (asif nil)

error:
Error while parsing arguments to DEFMACRO ASIF:
  too few elements in
    (NIL)
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 1


call_form: (asif nil nil)

expanded:
(let ((it nil))
  (if it
      nil
      (symbolic ignore-first nil nil)))


call_form: (asif nil (progn))

expanded:
(let ((it nil))
  (if it
      (progn)
      (symbolic ignore-first nil nil)))


call_form: (asif nil :key nil)

expanded:
(let ((it nil))
  (if it
      :key
      (symbolic ignore-first nil nil)))


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

error:
Error while parsing arguments to DEFMACRO ASIF:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 1


macro_name: SCOND

call_form:
(scond
  nil)

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


call_form:
(scond
  nil
  nil)


call_form:
(scond
  nil
  (progn))


call_form:
(scond
  nil
  :key
  nil)


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

expanded: (symbolic if quote (progn lol-gen::some-name) nil)


macro_name: AIF

call_form: (aif)

error:
Error while parsing arguments to DEFMACRO AIF:
  too few elements in
    ()
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 0


call_form: (aif nil)

error:
Error while parsing arguments to DEFMACRO AIF:
  too few elements in
    (NIL)
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 1


call_form: (aif nil nil)

expanded:
(anaphoric if
    nil
  nil
  nil)


call_form: (aif nil (progn))

expanded:
(anaphoric if
    nil
  (progn)
  nil)


call_form: (aif nil :key nil)

expanded:
(anaphoric if
    nil
  :key
  nil)


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

error:
Error while parsing arguments to DEFMACRO AIF:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (TEST THEN &OPTIONAL ELSE):
  between 2 and 3 expected, but got 1


macro_name: ACOND

call_form:
(acond
  nil)


call_form:
(acond
  nil
  nil)


call_form:
(acond
  nil
  (progn))


call_form:
(acond
  nil
  :key
  nil)


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

expanded:
(anaphoric if
    quote
  (progn lol-gen::some-name)
  nil)


macro_name: SETYPECASE

call_form: (setypecase)

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


call_form: (setypecase nil)

expanded: (symbolic etypecase nil)


call_form:
(setypecase nil
  nil)

expanded: (symbolic etypecase nil nil)


call_form:
(setypecase nil
  (progn))

expanded: (symbolic etypecase nil (progn))


call_form:
(setypecase nil
  :key
  nil)

expanded: (symbolic etypecase nil :key nil)


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


macro_name: SWHEN

call_form: (swhen)

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


call_form: (swhen nil)

expanded: (symbolic when nil)


call_form:
(swhen nil
  nil)

expanded: (symbolic when nil nil)


call_form:
(swhen nil
  (progn))

expanded: (symbolic when nil (progn))


call_form:
(swhen nil
  :key
  nil)

expanded: (symbolic when nil :key nil)


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

expanded: (symbolic when 'lol-gen::some-name)


macro_name: ACTYPECASE

call_form: (actypecase)

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


call_form: (actypecase nil)

expanded:
(anaphoric ctypecase
    nil)


call_form:
(actypecase nil
  nil)

expanded:
(anaphoric ctypecase
    nil
  nil)


call_form:
(actypecase nil
  (progn))

expanded:
(anaphoric ctypecase
    nil
  (progn))


call_form:
(actypecase nil
  :key
  nil)

expanded:
(anaphoric ctypecase
    nil
  :key
  nil)


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

expanded:
(anaphoric ctypecase
    'lol-gen::some-name)


macro_name: AECASE

call_form: (aecase)

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


call_form: (aecase nil)

expanded:
(anaphoric ecase
    nil)


call_form:
(aecase nil
  nil)

expanded:
(anaphoric ecase
    nil
  nil)


call_form:
(aecase nil
  (progn))

expanded:
(anaphoric ecase
    nil
  (progn))


call_form:
(aecase nil
  :key
  nil)

expanded:
(anaphoric ecase
    nil
  :key
  nil)


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

expanded:
(anaphoric ecase
    'lol-gen::some-name)