anchor.diff:  ;; conditions
   
   (define-condition redis-error (error)
  -  ((message :initarg :message :reader redis-error-message))
  +  ((message
  +    :initarg  :message
  +    :reader   redis-error-message)
  +   (comment
  +    :initform nil
  +    :initarg  :comment
  +    :reader   redis-error-comment))
     (:report (lambda (e stream)
  -             (format stream "Redis error: ~A" (redis-error-message e))))
  +             (format stream
  +                     "Redis error: ~A~:[~;~2&~:*~A~]"
  +                     (redis-error-message e)
  +                     (redis-error-comment e))))
     (:documentation "This is the condition type that will be used to
   signal virtually all Redis-related errors."))
   
  
positive.code:   (:documentation "Representation of a Redis connection."))
  
  (defmethod connection-external-format ((connection redis-connection))
    (make-external-format (connection-encoding connection) :eol-style :crlf))
  
  (defmethod initialize-instance :after ((connection redis-connection) &key)
    (open-connection connection))
    
  (defun open-connection (connection)
    "Connect a connection object."
    (handler-case
        (setf (connection-stream connection)
              (make-flexi-stream
               (socket-stream
  
negative.code: 
  (defmethod tell (type cmd &rest args)
    (declare (ignore cmd args))
    (error "Commands of type ~A are not supported." type))
  
  (defmethod tell ((type (eql :bulk)) cmd &rest args)
    (multiple-value-bind (args bulk) (butlast2 args)
      (check-type bulk string)
      (write-redis-line "~A~{ ~A~} ~A" cmd args (byte-length bulk))
      (write-redis-line "~A" bulk)))
  
  (defmethod tell ((type (eql :inline)) cmd &rest args)
    (write-redis-line "~A~{ ~A~}" cmd args))
  
  (defmethod tell ((type (eql :inline)) (cmd (eql 'SORT)) &rest args)
    (flet ((send-request (key &key by get desc alpha start count)
             (unless (or (and start count)
                         (and (null start) (null count)))
               (error "START and COUNT must be either both NIL or both non-NIL."))
             (write-redis-line "SORT ~a~:[~; BY ~:*~a~]~{ GET ~a~}~:[~; DESC~]~:[~; ALPHA~]~:[~; LIMIT ~:*~a ~a~]"
                               key by (mklist get) desc alpha start count)))
      (apply #'send-request args)))
  
  ;; (defmethod tell ((type (eql :inline)) (cmd (eql 'SORT)) &rest args)
  ;;   (destructuring-bind (key . options) args
  ;;     (let ((by    (getf options :by))
  ;;           (get   (mklist (getf options :get)))
  ;;           (desc  (getf options :desc))
  ;;           (alpha (getf options :alpha))
  ;;           (start (getf options :start))
  ;;           (count (getf options :count)))
  ;;       (assert (or (and start count)
  ;;                   (and (null start) (null count)))
  ;;               ()
  ;;               "START and COUNT must be either both NIL or both non-NIL.")
  ;;       (write-redis-line "SORT ~a~:[~; BY ~:*~a~]~{ GET ~a~}~:[~; DESC~]~:[~; ALPHA~]~:[~; LIMIT ~:*~a ~a~]"
  ;;                         key by get desc alpha start count))))
  
  (defmethod tell ((type (eql :multi)) cmd &rest args)
    (let ((bulks (cons (string cmd) args)))
  