anchor.diff:  
   (defun extend-vector-output-stream-buffer (extension stream &key (start 0) (end (length extension)))
     (declare (optimize speed)
  +           (type array-index start end)
              (type vector extension))
     (vector-extend extension (vector-stream-vector stream) :start start :end end)
     (incf (vector-stream-index stream) (- end start))
  
positive.code:     (setf (vector-stream-vector stream) (make-vector-stream-buffer))))
  
  (defmacro with-output-to-sequence ((var &key (return-as ''vector) (element-type '':default)
                                          (external-format '*default-character-encoding*))
                                     &body body)
    "Creates an IN-MEMORY output stream, binds VAR to this stream and then executes the code in BODY.  The stream stores data of type ELEMENT-TYPE \(a subtype of OCTET). The stream is automatically closed on exit from WITH-OUTPUT-TO-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is a vector \(or a list if AS-LIST is true) containing the octets that were sent to the stream within BODY."
    (multiple-value-bind (body declarations) (parse-body body)
  
negative.code:   nil)
  
  (defun make-in-memory-output-stream (&key (element-type :default)
                                       external-format
                                       initial-buffer-size)
    "Returns a binary output stream which accepts objects of type ELEMENT-TYPE \(a subtype of OCTET) and makes available a sequence that contains the octes that were actually output."
    (declare (optimize speed))
    (unless external-format
      (setf external-format *default-character-encoding*))
    (when (eq element-type :bivalent)
      (setf element-type :default))
    (make-instance 'vector-output-stream
                   :vector (make-vector-stream-buffer
                            :element-type (cond
                                            ((or (eq element-type :default)
                                                 (equal element-type '(unsigned-byte 8)))
                                             '(unsigned-byte 8))
                                            ((eq element-type 'character)
                                             'character)
                                            ((subtypep element-type '(unsigned-byte 8))
                                             '(unsigned-byte 8))
                                            (t (error "Illegal element-type ~S" element-type)))
                            :initial-size initial-buffer-size)
                   :element-type element-type
                   :external-format (ensure-external-format external-format)))
  
  