anchor.diff:    (assert (and (listp values) (> (length values) 0)))
     (dolist (item values)
       (assert (numberp item)))
  -  (push '(+sph-filter-values+ attr values (cond (exclude 1) (t 0))) (filters client))
  +  (push `(,+sph-filter-values+ ,attr ,values ,(cond (exclude 1) (t 0))) (filters client))
     client)
   
   
  
positive.code:                      (concatenate 'string
                                    (pack "N/a*" attr)
                                    (pack "N" type)
                                    (cond
  
  
                     (when (hash-table-p filter)
                       (concatenate 'string
                                    (pack "N/a*" (gethash 'attr filter))
                                    (let ((type (gethash 'type filter)))
                                      (concatenate 'string
                                                   (pack "N" type)
                                                   (cond ((eql type +sph-filter-values+)
                                                          (%pack-list-signed-quads (gethash 'values filter)))
                                                         ((eql type +sph-filter-range+)
                                                          (concatenate 'string (pack "q>" (gethash 'min filter))
                                                                       (pack "q>" (gethash 'max filter))))
                                                         ((eql type +sph-filter-floatrange+)
                                                          (concatenate 'string (%pack-float (gethash 'min filter))
                                                                       (%pack-float (gethash 'max filter))))
                                                         (t
                                                          (error "Unhandled filter type ~S" type)))
                                                   (pack "N" (gethash 'exclude filter)))))))
         filters))
  
  
  (defun %pack-hash (hash-table)
  
negative.code: 
  (defmethod %set-filter-range ((client sphinx-client) type attr min max &key (exclude nil))
    (assert (and (numberp min) (numberp max) (>= max min)))
    (push `(,type ,attr ,min ,max ,(cond (exclude 1) (t 0))) (filters client))
    client)
  
  ;;   (let ((filter (make-hash-table)))
  