anchor.diff:  
   (defmethod list-api-resource-functions ((api-resource api-resource))
     (loop for resource-operation being the hash-values of (resource-operations api-resource)
  -       collect resource-operation))
  +     collect resource-operation))
   
   (defmethod allowed-methods ((api-resource api-resource))
     (let ((methods nil))
       (loop for resource-operation in (list-api-resource-functions api-resource)
  -	 do (pushnew (request-method resource-operation) methods))
  +       do (pushnew (request-method resource-operation) methods))
       methods))
   
   (defgeneric resource-http-options (resource api)
     (:method ((resource api-resource) api)
       (flet ((format-allowed-methods (methods)
  -	   (format nil "~{~A~^, ~}"
  -		   (mapcar #'string methods))))
  -    (setf (hunchentoot:header-out "Allow")
  -	  (format-allowed-methods (allowed-methods resource))))))
  +             (format nil "~{~A~^, ~}"
  +                     (mapcar #'string methods))))
  +      (setf (hunchentoot:header-out "Allow")
  +            (format-allowed-methods (allowed-methods resource))))))
   
   (defmacro with-api-resource (resource &body body)
     "Execute body under resource scope.
  
positive.code: 
  (defun process-api-resource-options (resource options)
    (loop for option in options
         do (process-api-resource-option (first option) resource (rest option))))
  
  (defun configure-api-resource (api-or-name resource-name &rest options)
    (let ((api (if (symbolp api-or-name)
  		 (find-api api-or-name)
  		 api-or-name)))
      (let ((resource (find-api-resource resource-name :api api)))
        (process-api-resource-options resource options))))
  
negative.code: 
  (defun call-with-api-resource (resource function)
    (let ((*api-resource* (if (symbolp resource)
                              (find-api-resource resource)
                              resource)))
      (funcall function)))
  
  (defun find-api-resource (name &key (error-p t) api)
    "Find api resource by name in the current api"
    (let ((api (or api
                   *api*
                   (error "No api in scope"))))
      (multiple-value-bind (resource found-p)
          (gethash name (resources api))
        (when (and (not found-p)
                   error-p)
          (error "Resource ~S not found in ~A" name api))
        resource)))
  
  (defmacro define-api-resource (name options &body functions)
    "Define an api resource."
    `(progn
       (apply #'make-instance
              'api-resource
              :name ',name
              ',options)
       (with-api-resource ,name
         ,@(loop for x in functions
              collect `(define-resource-operation ,@x)))
       ;; Generate client API access function
       ,@(let ((*register-resource-operation* nil))
           (loop for x in functions
              collect (client-stub
                       (destructuring-bind (name attributes args &rest options) x
                         (make-resource-operation
                          name
                          attributes
                          args
                          options))
                       :package
                       (or (and (getf options :client-package)
                                (find-package (getf options :client-package)))
                           *package*)
                       :export-p (getf options :export-client-functions))))))
  
  (defmacro implement-api-resource (api-name name-and-options &body resource-operations-implementations)
    "Define an api resource implementation"
    (multiple-value-bind (name options)
        (if (listp name-and-options)
            (values (first name-and-options)
                    (rest name-and-options))
            (values name-and-options nil))
      `(let* ((api (find-api ',api-name))
              (resource (find-api-resource ',name :api api)))
         (process-api-resource-options resource ',options)
  
         ;; Define resource operation implementations
         ,@(loop for resource-operation-implementation in resource-operations-implementations
              collect `(implement-resource-operation ,api-name ,@resource-operation-implementation)))))
  
  (defun parse-resource-path (string)
    (let* ((vars nil)
  