anchor.diff:  	(declare (ignore n/a))
   	(setf (gethash (aref found 0) map) (aref found 1))))
       map))
  -|#
   
   (defun preparse-uri-parameters->list (schema)
     "Turns st. like 'bla/{id:[0-9]+}/{name:.+}' in a parameter->regexpmap list"
  
positive.code: 		   (t 
  		    (rec str start (1+ pos) acc)))))
      (rec uri 0 0 nil)))
  	       
      
  
  (defun split-on-placeholders (uri)
    "splits a sequence on the template placeholder blocks"
    (let ((split-symbol #\U00046A76)) ;;could be anything
      (split-sequence split-symbol 
  		    (regex-replace-all "{[^\{]+}" uri (format nil "~c" split-symbol)))))
  
  
  
  (defun parse-schema (schema)
    "Splits static uri parts and template blocks and replaces template blocks with their parsing"
    (let ((parameters (preparse-uri-parameters->list schema))
  	(holders (split-on-placeholders schema))
  	(result))
      (loop for i in holders with n = -1 do
  	 (push i result)
  	 (push (nth (incf n) parameters) result))
      (remove-if #'(lambda (x)
  		   (or (null x)
  		       (= 0 (length x))))
  	       (nreverse result))))
  
  (defun parse-uri (schema uri)
    "Parses URI against SCHEMA and returns a hashtable with all pathvariable bindings"
    (when (not 
  	 (scan 
  	  (schema->regexpurl schema)
  	  uri))
      (error "Uri does not match schema"))
    (let ((parsed (parse-schema schema))
  	(map (make-hash-table :test #'equalp)))
  	
      (loop for token in parsed do
  	 (if (listp token)
  	     (let ((regexp (getf token :regexp))
  		   (key (getf token :key)))
  
negative.code: 	(push (list :key (aref found 0) :regexp (aref found 1)) lst)))
      (reverse lst)))
  
        
  (defun split-template-blocks (uri)
    "splits an uri to seperate the template placeholder blocks so that '/bla/{var:.+}' becomes ('/bla/' '{var:.+}')"
  