anchor.diff:  
   (defmethod tell (type cmd &rest args)
     (declare (ignore cmd args))
  -  (error "Type ~A commands are not supported." type))
  +  (error "Commands of type ~A are not supported." type))
   
   (defmethod tell ((type (eql :bulk)) cmd &rest args)
     (multiple-value-bind (args bulk) (butlast2 args)
  -    (assert (and bulk (typep bulk 'string))
  -            (bulk)
  -            "Bulk Redis data must be a string")
  +    (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)
  -  (dolist (arg args)
  -    (assert (not (blankp arg)) () "Redis argument must be non-empty"))
     (write-redis-line "~A~{ ~A~}" cmd args))
   
   (defmethod tell ((type (eql :inline)) (cmd (eql 'SORT)) &rest args)
  -  (destructuring-bind (key . options) args
  -    (assert (not (blankp key)) () "Redis argument must be non-empty")
  -    (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 END 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))))
  +  (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)))
  
positive.code: ;; conditions
  
  (define-condition redis-error (error)
    ((message :initarg :message :reader redis-error-message))
    (:report (lambda (e stream)
               (format stream "Redis error: ~A" (redis-error-message e))))
    (:documentation "This is the condition type that will be used to
  signal virtually all Redis-related errors."))
  
  
negative.code:                                  (encoding :utf-8))
                             &body body)
    "Evaluate BODY with the current connection bound to a new connection
  specified by the given HOST, PORT, and ENCODING."
    `(let ((*connection* (make-instance 'redis-connection
                                        :host ,host
                                        :port ,port
  