anchor.diff:  
   (defun register-schema (name definition)
     (setf (gethash name *schemas*)
  -	definition))
  +        definition))
   
   (defmacro define-schema (name schema)
     "Define a schema"
     `(register-schema ',name
  -		    (schema ,schema)))
  +                    (schema ,schema)))
   
   (defmacro schema (schema-def)
     `(quote ,schema-def))
  
positive.code: 
  (defmethod parse-with-schema (schema string-or-data &optional (format :json))
    (let ((data
  	 (if (stringp string-or-data)
  	     (rs::parse-api-input format string-or-data)
  	     string-or-data)))
      (%parse-with-schema (schema-type schema)
  			schema
  			data)))
  
  (defmethod %parse-with-schema ((schema-type (eql :element))
  			       schema data)
    (if (null data)
        data
        (loop
  	 for schema-attribute in (element-attributes schema)
  	 for data-attribute = (assoc (string (attribute-name schema-attribute))
  				     data
  				     :test #'equalp
  				     :key #'string)
  	 appending
  	   (progn
  	     (when (and (not data-attribute)
  			(not (attribute-optional-p schema-attribute)))
  	       (validation-error "Attribute ~a not found in ~a"
  				 (attribute-name schema-attribute)
  				 data))
  	     (when (or (equalp (attribute-type schema-attribute) :boolean)
  		       (not (null (cdr data-attribute))))
  	       (list (cons (intern (string (attribute-name schema-attribute)) :keyword)
  			   (parse-schema-attribute-value (attribute-type schema-attribute)
  							 (cdr data-attribute)))))))))
  
  (defmethod %parse-with-schema ((schema-type (eql :list))
  			       schema data)
    (let ((elem-schema (second schema)))
      (flet ((parse-elem (elem)
  	     (if (symbolp elem-schema)
  		 (parse-schema-attribute-value elem-schema elem)
  		 (parse-with-schema elem-schema elem))))
      (loop for elem in data
  	 collect (parse-elem elem)))))
  
  (defmethod parse-schema-attribute-value ((type (eql :string)) data)
    (string data))
  
negative.code:                              Probably obtained from parse-api-input.
  
  See: parse-api-input (function)"
  
    (let ((unserializer (element-unserializer element))
          (element-class (element-class element)))
      (cond
        (unserializer (funcall unserializer input))
        (element-class (unserialize-schema-element-to-class element input element-class))
  