anchor.diff:    (skip-spaces buffer)
     (read-from-string (subseq-until buffer #\] #\} #\,))) ;; only these characters are allowed to actually end a number
   
  -(defun read-json (string)
  +(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)))
  -    (skip-to buffer #\{)
  -    (read-object buffer)))
  -
  +    (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)))
positive.code:   (setf (buffer-mark buffer) (buffer-index buffer)))
  
  (defun skip-to (buffer last-char)
    "Skips characters until <char> has been found.  <char> is the last char which is skipped"
    (declare (type buffer buffer)
  	   (type character last-char))
    (loop until (char= (current-char buffer) last-char)
       do (next-char buffer))
    (values))
  
  (defun skip-spaces (buffer)
    "Skips spaces, tabs and newlines until a non-space character has been found"
    (loop while (find (current-char buffer) +space-characters+ :test #'char=)
  
negative.code:      do (next-char buffer))
    (subseq-buffer-mark buffer))
  
  (defun subseq-tree (buffer end-char tree)
    "Returns a sequence of the buffer, reading everything that matches with the given tree before end-char is found.  end-char is not read from the buffer
   Returns nil if no sequence matching the tree could be found.  It then stops iterating at the failed position"
    (declare (type buffer buffer)
  	   (type character end-char))
    (mark-buffer buffer)
    (let ((accepted-p nil))
      (loop while (and tree (char/= (current-char buffer) end-char))
         do (progn (multiple-value-setq (tree accepted-p) (iterate-tree tree (current-char buffer)))
  		 (next-char buffer)))
      (values accepted-p (if accepted-p (subseq-buffer-mark buffer) ""))))
  
  (defun read-object (buffer)
    "reads a key-value pair into the hash"
    (declare (type buffer buffer))
    (loop until (progn (skip-spaces buffer)
  		     (char= (fetch-char buffer) #\})) ; we may fetch-char here, as the character is a #\, to be skipped if it is not a #\}
       collect (cons (read-key buffer) (read-value buffer))))
  
  (defun read-partial-object (buffer tree)
    "Reads an object from the buffer, but only when the key matches a key in the tree"
    (declare (type buffer buffer)
  	   (type (or cons nil) tree))
    (loop until (progn (skip-spaces buffer)
  		     (char= (fetch-char buffer) #\})) ; we may fetch-char here, as the character is a #\, to be skipped if it is not a #\}
       append (multiple-value-bind (found-p key)
  		(read-partial-key buffer tree)
  	      (if found-p
  		  (list (cons key (read-value buffer)))
  		  (progn (skip-value buffer) nil)))))
  
  (defun skip-object (buffer)
    "Skips an object from the buffer"
    (declare (type buffer buffer))
    (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 }
       do (skip-key buffer) (skip-value buffer)))
  
  (defun read-partial-key (buffer tree)
    "reads a key from the buffer.  Returns (values key T) if the key was found as a valid key in the tree, or (values nil nil) if it was not"
    (declare (type buffer buffer)
  	   (type (or cons nil) tree))
    (skip-to buffer #\")
    (multiple-value-bind (accepted-p solution)
        (subseq-tree buffer #\" tree)
      (declare (type (or nil T) accepted-p)
  	     (type simple-string solution))
      (skip-to buffer #\") ;; clean up mess
      (values accepted-p solution)))
  
  (defun read-key (buffer)
    "reads a key from the key-value list"
    (declare (type buffer buffer))
    (skip-to buffer #\")
    (parse-string buffer))
  
  (defun skip-key (buffer)
    "reads a key from the key-value list"
    (declare (type buffer buffer))
    (skip-to buffer #\")
    (skip-string buffer))
  
  (defun read-value (buffer)
    "Reads a value from the stream.
  