anchor.diff:       #\Newline "\\n"
        #\Return "\\r"
        #\Tab "\\t")))
  -       
   
   (defmethod encode ((string string) &optional (stream *standard-output*))
  -  (with-standard-output-to (stream)
  -    (write-char #\")
  -    (dotimes (i (length string))
  -      (let* ((char (aref string i))
  -             (replacement (gethash char *char-replacements*)))
  -        (if replacement
  -            (write-string replacement)
  -            (write-char char))))
  -    (write-char #\")
  -    string))
  +  (write-char #\")
  +  (dotimes (i (length string))
  +    (let* ((char (aref string i))
  +           (replacement (gethash char *char-replacements*)))
  +      (if replacement
  +          (write-string replacement)
  +          (write-char char))))
  +  (write-char #\")
  +  string)
   
   (defmethod encode ((object rational) &optional (stream *standard-output*))
     (encode (float object) stream)
  
positive.code: (in-package :yason)
  
  (defvar *json-output*)
  
  (defmacro with-standard-output-to ((stream) &body body)
    `(let ((*standard-output* ,stream))
       ,@body))
  
  (defgeneric encode (object &optional stream)
  
  
negative.code:   (princ object stream))
  
  (defmethod encode ((object hash-table) &optional (stream *standard-output*))
    (write-char #\{)
    (let (printed)
      (maphash (lambda (key value)
                 (if printed
                     (write-char #\,)
                     (setf printed t))
                 (encode key stream)
                 (write-char #\:)
                 (encode value stream))
               object))
    (write-char #\})
    object)
  
  (defmethod encode ((object vector) &optional (stream *standard-output*))
    (write-char #\[)
    (let (printed)
      (loop
         for value across object
         do
         (when printed
           (write-char #\,))
         (setf printed t)
         (encode value stream)))
    (write-char #\])
    object)
  
  (defmethod encode ((object list) &optional (stream *standard-output*))
    (write-char #\[)
    (let (printed)
      (dolist (value object)
        (if printed
            (write-char #\,)
            (setf printed t))
        (encode value stream)))
    (write-char #\])
    object)
  
  (defmethod encode ((object (eql 'true)) &optional (stream *standard-output*))
  