anchor.diff:  (defvar *route-section* "")
   
   (defclass route-table ()
  -  ((get :initform (http-routes.matcher::make-node))
  -   (head :initform (http-routes.matcher::make-node))
  -   (post :initform (http-routes.matcher::make-node))
  -   (put :initform (http-routes.matcher::make-node))
  -   (delete :initform (http-routes.matcher::make-node))
  -   (trace :initform (http-routes.matcher::make-node))
  -   (options :initform (http-routes.matcher::make-node))
  -   (connect :initform (http-routes.matcher::make-node))
  -   (patch :initform (http-routes.matcher::make-node))
  +  ((methods :initform (alexandria:alist-hash-table
  +                       `((:get . ,(http-routes.matcher::make-node))
  +                         (:head . ,(http-routes.matcher::make-node))
  +                         (:post . ,(http-routes.matcher::make-node))
  +                         (:put . ,(http-routes.matcher::make-node))
  +                         (:delete . ,(http-routes.matcher::make-node))
  +                         (:trace . ,(http-routes.matcher::make-node))
  +                         (:options . ,(http-routes.matcher::make-node))
  +                         (:connect . ,(http-routes.matcher::make-node))
  +                         (:patch . ,(http-routes.matcher::make-node)))))
      (named-routes :initform (make-hash-table))))
   
  -(defun make-route-table ()
  -  (make-instance 'route-table))
  +(defun make-route-table (&rest methods)
  +  (let ((route-table (make-instance 'route-table)))
  +    (loop for method in methods do
  +          (setf (gethash method (slot-value route-table 'methods)) (http-routes.matcher::make-node)))
  +    route-table))
   
   (defun named-routes ()
     (slot-value *route-table* 'named-routes))
  
positive.code:            (let ((*route-section* section))
               ,@routes))))))
  
  (defmethod route-table-routes ((method (eql :get)))
    (slot-value *route-table* 'get))
  (defmethod route-table-routes ((method (eql :post)))
    (slot-value *route-table* 'post))
  (defmethod route-table-routes ((method (eql :put)))
    (slot-value *route-table* 'put))
  (defmethod route-table-routes ((method (eql :delete)))
    (slot-value *route-table* 'delete))
  (defmethod route-table-routes ((method (eql :trace)))
    (slot-value *route-table* 'trace))
  (defmethod route-table-routes ((method (eql :options)))
    (slot-value *route-table* 'options))
  (defmethod route-table-routes ((method (eql :connect)))
    (slot-value *route-table* 'connect))
  (defmethod route-table-routes ((method (eql :patch)))
    (slot-value *route-table* 'patch))
  
  (defun add-route-to-routes (routes path route)
    (let ((*routes* routes))
  
negative.code:           (path-generator (if ,name (create-path-generator ,name path))))
       (let ((route (add-route% path ,handler ,methods  ,defaults ,validators (if ,name path-generator nil))))
         (if ,name
             (add-named-route ,name route))
         route)))
  
  (defun get (uri &key handler name defaults validators)
  