anchor.diff:        ""
         (jsown:to-json response)))
   
  -(defun mk-response-method (components callback)
  +(defun mk-response-method (components callback applied-parameters-p)
     "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)))
  +    (if applied-parameters-p
  +        (response-json-parser
  +         (apply callback (parse-request-uri-as-list components)))
  +        (funcall (alexandria:compose #'response-json-parser
  +                                     callback
  +                                     #'parse-request-uri)
  +                 components))))
   
  -(defun specify-call (&key method components callback)
  +(defun specify-call (&key method components callback applied-parameters-p)
     "defines a json call functionally.
   
     - method :: contains a :get :put :post :delete symbol.
  
positive.code:          (setf (gethash symbol variables-hash) value))
      variables-hash))
  
  (defun response-json-parser (response)
    "Parses the json for the response content by the matched
    method.
  
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
  