anchor.diff:             (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 route-table-routes (method)
  +  (gethash method (slot-value *route-table* 'methods)))
   
   (defun add-route-to-routes (routes path route)
     (let ((*routes* routes))
  
positive.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)
  
negative.code: (defvar *route-section* "")
  
  (defclass route-table ()
    ((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 (&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))
  