anchor.diff:                                     :test #'equalp
                                      :key #'string)
        :do
  -     (when (and (not data-attribute)
  -                (not (attribute-optional-p schema-attribute)))
  -       (let ((error-msg (or (attribute-option :not-provided-message schema-attribute)
  -                            (format nil "Attribute ~a not provided"
  -                                    (attribute-name schema-attribute)))))
  -         (validation-error error-msg)))
  -     (when (not (and (attribute-optional-p schema-attribute)
  +     (cond
  +       ((and (not data-attribute)
  +             (not (attribute-optional-p schema-attribute)))
  +        (let ((error-msg (or (attribute-option :not-provided-message schema-attribute)
  +                             (format nil "Attribute ~a not provided"
  +                                     (attribute-name schema-attribute)))))
  +          (validation-error error-msg)))
  +       ((not data-attribute)
  +        ;; Nothing to validate
  +        )
  +       ((not (and (attribute-optional-p schema-attribute)
                        (null data-attribute)))
          (schema-validate (attribute-type schema-attribute)
                           (cdr data-attribute)
  -                        schema-attribute))))
  +                        schema-attribute)))))
   
   (defmethod %schema-validate ((schema-type (eql :list)) schema data &optional attribute)
     (let ((list-type (or (and (listp schema)
  
positive.code:   (destructuring-bind (_ object-name attributes &rest options) schema-object
      (declare (ignore _))
      (with-object ((or (and (stringp object-name)
                              object-name)
                         (symbol-name object-name))
                     :serializer serializer
                     :stream stream)
        (loop for attribute in attributes
           do
             (serialize-schema-attribute attribute serializer input stream)))))
  
negative.code:            (cond
               ((and (not data-attribute)
                     (not (attribute-optional-p schema-attribute)))
                (validation-error "Attribute ~a not found in ~a"
                                  (attribute-name schema-attribute)
                                  data))
               ((not data-attribute)
                ;; don't add the attribute to the data in this case
                ;; idea to think of: we could use the attribute default value if specified, instead
                nil)
               ((or (equalp (attribute-type schema-attribute) :boolean)
                    (not (null (cdr data-attribute))))
                (list (cons (intern (string (attribute-name schema-attribute)) :keyword)
                            (parse-schema-attribute schema-attribute (cdr data-attribute)))))))))
  
  (defun parse-schema-attribute (schema-attribute value)
    (let ((parsed-value (parse-schema-attribute-value (attribute-type schema-attribute) value)))
  