anchor.diff:         #+abcl &allow-other-keys)
     (if enabled
         (make-instance 'unserialization-resource-operation-implementation-decoration
  -		     :schema schema
  -		     :format format
  -		     :decorates resource-operation-implementation)
  +                     :schema schema
  +                     :format format
  +                     :decorates resource-operation-implementation)
         resource-operation-implementation))
  -  
  +
   (defmethod rs::execute :around ((decoration unserialization-resource-operation-implementation-decoration)
  -			    &rest args)
  +                                &rest args)
     (let ((posted-content (first args))) ;; Asume the posted content is in the first argument
       (apply #'call-next-method
  -	   (unserialize-with-schema (unserialization-schema decoration)
  -				    posted-content
  -				    (unserialization-format decoration))
  -	   (rest args))))
  +           (unserialize-with-schema (unserialization-schema decoration)
  +                                    posted-content
  +                                    (unserialization-format decoration))
  +           (rest args))))
   
   (cl-annot:defannotation unserialization (args resource-operation-implementation)
       (:arity 2)
  
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: (defun attribute-type-name (attribute)
    (let ((attribute-type (attribute-type attribute)))
      (if (listp attribute-type)
          (first attribute-type)
          attribute-type)))
  
  (defun attribute-options (attribute)
    (cddr attribute))
  