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:      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:   (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
   see: skip-until"
    (declare (type buffer buffer)
  	   (type character last-char))
    (skip-until buffer last-char)
    (next-char buffer))
  (defun skip-until (buffer last-char)
    "Skips characters until <char> has been found.  <char> is NOT skipped
   See: skip-to"
    (declare (type buffer buffer)
  	   (type character last-char))
    (loop until (char= (current-char buffer) last-char)
       do (next-char buffer))
    (values))
  
  (defun skip-until* (buffer &rest chars)
    "Skips characters until one of teh characters in <chars> has been found.  The character which was found is not read from the buffer"
    (declare (type buffer buffer))
    (loop until (find (current-char buffer) chars :test #'char=)
       do (next-char buffer))
    ())
  
  (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=)
  