macro_name: SET-DATA

library: cl-algebraic-data-type

call_form: (set-data)

status: expansion-error

error:
Error while parsing arguments to DEFMACRO SET-DATA:
  too few elements in
    ()
  to satisfy lambda list
    (OBJ (NAME &REST NEW-VALUES)):
  exactly 2 expected, but got 0


call_form: (set-data nil)

error:
Error while parsing arguments to DEFMACRO SET-DATA:
  too few elements in
    (NIL)
  to satisfy lambda list
    (OBJ (NAME &REST NEW-VALUES)):
  exactly 2 expected, but got 1


call_form: (set-data nil nil)

error:
Error while parsing arguments to DEFMACRO SET-DATA:
  too few elements in
    ()
  to satisfy lambda list
    (NAME &REST NEW-VALUES):
  at least 1 expected, but got 0


call_form: (set-data nil (progn))

expanded:
(let ((#:once133 nil))
  (psetf))

status: verified


call_form: (set-data nil :key nil)

error:
Error while parsing arguments to DEFMACRO SET-DATA:
  too many elements in
    (NIL :KEY NIL)
  to satisfy lambda list
    (OBJ (NAME &REST NEW-VALUES)):
  exactly 2 expected, but got 3


call_form: (set-data 'lol-gen::some-name)

error:
Error while parsing arguments to DEFMACRO SET-DATA:
  too few elements in
    ('LOL-GEN::SOME-NAME)
  to satisfy lambda list
    (OBJ (NAME &REST NEW-VALUES)):
  exactly 2 expected, but got 1


macro_name: MATCH

call_form: (match)

error:
Error while parsing arguments to DEFMACRO MATCH:
  too few elements in
    ()
  to satisfy lambda list
    (ADT OBJ &BODY CLAUSES):
  at least 2 expected, but got 0


call_form: (match nil)

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


call_form:
(match nil
    nil)

expanded:
(let ((#:obj-134 nil))
  (check-type #:obj-134 nil)
  (etypecase #:obj-134))


call_form:
(match nil
    (progn))

expanded:
(let ((#:obj-135 (progn)))
  (check-type #:obj-135 nil)
  (etypecase #:obj-135))


call_form:
(match nil
    :key
  nil)

expanded:
(let ((#:obj-136 :key))
  (check-type #:obj-136 nil)
  (etypecase #:obj-136
    (nil
     (with-data nil
         #:obj-136))))


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

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


macro_name: DEFDATA

call_form: (defdata)

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


call_form: (defdata nil)

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defstruct
      (nil (:constructor nil) (:copier nil) (:predicate nil)
       (:include algebraic-data-type)))
  'nil)


call_form:
(defdata nil
  nil)

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defstruct
      (nil (:constructor nil) (:copier nil) (:predicate nil)
       (:include algebraic-data-type)))
  (progn
   (eval-when (:compile-toplevel :load-toplevel :execute)
     (defstruct
         (nil (:include nil) (:constructor %nil) (:copier nil) (:predicate nil)
          (:print-function
           (lambda (#:object-141 #:stream-142 #:depth-143)
             (declare (ignore #:depth-143)
                      (ignorable #:object-141))
             (when *print-adt-readably* (write-string "#." #:stream-142))
             nil
             (prin1 'nil #:stream-142)
             nil)))
       #A((34) base-char . "A component of ADT COMMON-LISP:NIL")))
   (declaim (sb-ext:freeze-type nil))
   (defmethod make-load-form ((#:object-141 nil) &optional #:environment-144)
     (make-load-form-saving-slots #:object-141 :slot-names nil :environment
                                  #:environment-144))
   (define-constant nil (%nil)
                    #A((34) base-char . "A component of ADT COMMON-LISP:NIL"))
   (fmakunbound '%nil))
  'nil)


call_form:
(defdata nil
  (progn))

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defstruct
      (nil (:constructor nil) (:copier nil) (:predicate nil)
       (:include algebraic-data-type)))
  (progn
   (eval-when (:compile-toplevel :load-toplevel :execute)
     (defstruct
         (progn
          (:include nil)
          (:constructor %progn)
          (:copier nil)
          (:predicate nil)
          (:print-function
           (lambda (#:object-145 #:stream-146 #:depth-147)
             (declare (ignore #:depth-147)
                      (ignorable #:object-145))
             (when *print-adt-readably* (write-string "#." #:stream-146))
             nil
             (prin1 'progn #:stream-146)
             nil)))
       #A((34) base-char . "A component of ADT COMMON-LISP:NIL")))
   (declaim (sb-ext:freeze-type progn))
   (defmethod make-load-form ((#:object-145 progn) &optional #:environment-148)
     (make-load-form-saving-slots #:object-145 :slot-names nil :environment
                                  #:environment-148))
   (define-constant progn (%progn)
                    #A((34) base-char . "A component of ADT COMMON-LISP:NIL"))
   (fmakunbound '%progn))
  'nil)


call_form:
(defdata nil
  :key
  nil)

expanded:
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defstruct
      (nil (:constructor nil) (:copier nil) (:predicate nil)
       (:include algebraic-data-type)))
  (progn
   (eval-when (:compile-toplevel :load-toplevel :execute)
     (defstruct
         (:key (:include nil) (:constructor %key) (:copier nil)
          (:predicate nil)
          (:print-function
           (lambda (#:object-149 #:stream-150 #:depth-151)
             (declare (ignore #:depth-151)
                      (ignorable #:object-149))
             (when *print-adt-readably* (write-string "#." #:stream-150))
             nil
             (prin1 ':key #:stream-150)
             nil)))
       #A((34) base-char . "A component of ADT COMMON-LISP:NIL")))
   (declaim (sb-ext:freeze-type :key))
   (defmethod make-load-form ((#:object-149 :key) &optional #:environment-152)
     (make-load-form-saving-slots #:object-149 :slot-names nil :environment
                                  #:environment-152))
   (define-constant :key (%key)
                    #A((34) base-char . "A component of ADT COMMON-LISP:NIL"))
   (fmakunbound '%key))
  (progn
   (eval-when (:compile-toplevel :load-toplevel :execute)
     (defstruct
         (nil (:include nil) (:constructor %nil) (:copier nil) (:predicate nil)
          (:print-function
           (lambda (#:object-149 #:stream-150 #:depth-151)
             (declare (ignore #:depth-151)
                      (ignorable #:object-149))
             (when *print-adt-readably* (write-string "#." #:stream-150))
             nil
             (prin1 'nil #:stream-150)
             nil)))
       #A((34) base-char . "A component of ADT COMMON-LISP:NIL")))
   (declaim (sb-ext:freeze-type nil))
   (defmethod make-load-form ((#:object-149 nil) &optional #:environment-152)
     (make-load-form-saving-slots #:object-149 :slot-names nil :environment
                                  #:environment-152))
   (define-constant nil (%nil)
                    #A((34) base-char . "A component of ADT COMMON-LISP:NIL"))
   (fmakunbound '%nil))
  'nil)


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

error: ADT-NAME must either be a symbol, a singleton list with the ADT name as a symbol, or a list of two elements with the ADT name and :MUTABLE respectively. Given 'LOL-GEN::SOME-NAME.


macro_name: WITH-DATA

call_form: (with-data)

error:
Error while parsing arguments to DEFMACRO WITH-DATA:
  too few elements in
    ()
  to satisfy lambda list
    ((NAME &REST VARS) OBJ &BODY BODY):
  at least 2 expected, but got 0


call_form: (with-data nil)

error:
Error while parsing arguments to DEFMACRO WITH-DATA:
  too few elements in
    (NIL)
  to satisfy lambda list
    ((NAME &REST VARS) OBJ &BODY BODY):
  at least 2 expected, but got 1


call_form:
(with-data nil
    nil)

error:
Error while parsing arguments to DEFMACRO WITH-DATA:
  too few elements in
    ()
  to satisfy lambda list
    (NAME &REST VARS):
  at least 1 expected, but got 0


call_form:
(with-data nil
    (progn))


call_form:
(with-data nil
    :key
  nil)


call_form: (with-data 'lol-gen::some-name)

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