anchor.diff:  			(build-tree matching-lists))))))
   
   (defun iterate-tree (tree char)
  -  "Iterates a character-tree with the given character"
  +  "Iterates a character-tree with the given character
  + Returns two values, being the new tree and whether or not this is an end-point."
     (declare (type (or cons nil) tree)
   	   (type character char))
     (let ((solution (rest (find char tree :key #'first :test #'char=))))
  
positive.code:      do (next-char buffer))
    (subseq-buffer-mark buffer))
  
  (defun read-object (buffer)
    "reads a key-value pair into the hash"
    (declare (type buffer buffer))
    (let ((obj nil))
      (loop until (progn (skip-spaces buffer)
  		       (char= (fetch-char buffer) #\})) ; we may read-char here, as the character is a , to be skipped if it is not a }
         collect (cons (read-key buffer) (read-value buffer))) 
      obj))
  
  (defun read-key (buffer)
    "reads a key from the key-value list"
    (declare (type buffer buffer))
    (skip-to buffer #\")
    (parse-string buffer))
  
  (defun read-value (buffer)
    "Reads a value from the stream.
  
negative.code:   (skip-spaces buffer)
    (read-from-string (subseq-until buffer #\] #\} #\,))) ;; only these characters are allowed to actually end a number
  
  (defun skip-number (buffer)
    (declare (type buffer buffer))
    (skip-spaces buffer)
    (skip-until* buffer #\] #\} #\,))
  
  (defun read-json (buffer tree)
    "Reads a json object from the buffer, with the given tree as a character-tree"
    (skip-spaces buffer)
    (read-partial-object buffer tree))
  
  (defun yason (string &rest keywords-to-read)
    "Reads a json object from the given string, with the given keywords being the keywords which are fetched from the object"
    (let ((buffer (build-buffer string)))
      (read-json buffer (apply #'build-character-tree keywords-to-read))))
  (define-compiler-macro yason (string &rest keywords-to-read) ; this allows the character tree to be precompiled
    `(let ((buffer (build-buffer ,string)))
       (read-json buffer (build-character-tree ,@keywords-to-read))))
  
  (defun jason (string)
    "Reads a json object from the buffer"
    (let ((buffer (build-buffer string)))
      (skip-spaces buffer)
      (read-object buffer)))