anchor.diff:           (setf (gethash symbol variables-hash) value))
       variables-hash))
   
  +(defun parse-request-uri-as-list (components)
  +  (multiple-value-bind (s e starts ends)
  +      (cl-ppcre:scan (components-to-regex components "\\\\?.*$")
  +                     (hunchentoot:request-uri*))
  +    (declare (ignore s e))
  +    (loop for s across starts
  +       for e across ends
  +       collect (subseq (hunchentoot:request-uri*) s e))))
  +
   (defun response-json-parser (response)
     "Parses the json for the response content by the matched
     method.
  
positive.code:       ""
        (jsown:to-json response)))
  
  (defun mk-response-method (components callback)
    "constructs a method which parses <components> and calls
    <callback> with a hash containing the variables of the call as
    per `parse-request-content'."
    (lambda ()
      (wait-for-page)
      (setf (hunchentoot:content-type*) "application/json")
      (funcall (alexandria:compose #'response-json-parser
                                   callback
                                   #'parse-request-uri)
               components)))
  
  (defun specify-call (&key method components callback)
    "defines a json call functionally.
  
    - method :: contains a :get :put :post :delete symbol.
  
negative.code:   - callback :: function to be called to handle the request."
    (push (create-typed-regex-dispatcher method
                                         (components-to-regex* components)
                                         (mk-response-method components
                                                             callback
                                                             applied-parameters-p))
          hunchentoot:*dispatch-table*))
  
  (defmacro defcall (method (&rest components) &body body)
    "defines a webpage, consisting of <components>"
    (let ((variables (remove-if #'keywordp components))
          (method-symbol (intern (symbol-name method) :keyword)))
      `(specify-call
         :method ,method-symbol
         :components ,`(quote ,components)
         :callback (lambda (,@variables) ,@body)
         :applied-parameters-p t)))
  
  (defmacro with-parameters ((&rest parameters) &body body)
    `(let ,(loop for varname in parameters
  