anchor.diff:           (reconnect-all-routes)))))
   
   (defun create-route-from-symbol (symbol submodule)
  -  (make-instance 'simple-route
  +  (make-instance 'route
                    :template (concatenate 'list
                                           (submodule-full-baseurl submodule)
                                           (routes:parse-template (get symbol :template)
  
positive.code:                  (funcall arbitrary-requirement))
                 t)))))
  
  (defmethod process-route ((route base-route) bindings)
    (with-context (slot-value (slot-value route 'submodule)
                              'context)
      (setf (hunchentoot:content-type*)
            (route-content-type route))
      (render-object (route-render-method route)
                     (process-route/impl route bindings))))
  
  (defclass simple-route (base-route)
    ((symbol :initarg :symbol)))
  
  (defmethod process-route ((route simple-route) bindings)
    (let ((*route* route)
          (*submodule* (slot-value route 'submodule)))
      (call-next-method)))
  
  (defmethod process-route/impl ((route simple-route) bindings)
    (let ((*bindings* bindings))
      (funcall (slot-value route 'symbol))))
  
  (defmacro define-route (name (template &key
                                         (method :get)
  
negative.code: (in-package :restas)
  
  (defgeneric process-route (route bindings))
  
  (defclass route (routes:route)
    ((symbol :initarg :symbol)
     (submodule :initarg :submodule :initform nil)
     (content-type :initarg :content-type :initform nil :reader route-content-type)
     (required-method :initarg :required-method :initform nil :reader route-required-method)
     (arbitrary-requirement :initarg :arbitrary-requirement :initform nil :reader route-arbitrary-requirement)
  