anchor.diff:  (defun hamming (x y)
     "Calculates Hamming distance between two given strings, they have to be
   of the same length."
  -  (declare (type simple-string x y)
  +  (declare (type (simple-array character) x y)
              (inline length)
              (optimize (safety 0) (speed 3) (space 3)))
     (let ((result 0))
  
positive.code: (defun jaro (x y)
    "Calculates Jaro distance between two strings. Returned value is in range
  from 0 (no similarity) to 1 (exact match)."
    (declare (type simple-string x y)
             (inline length fast-find)
             (optimize (safety 0) (speed 1) (space 3)))
    (let* ((x-len (length x))
  
negative.code:         (let* ((x-i (char x i))
                 (y-j (char y j))
                 (cost (if (char= x-i y-j) 0 1)))
            (declare (type array-index cost))
            (setf (aref v1 (1+ j))
                  (min (1+ (aref v1 j))
                       (1+ (aref v0 (1+ j)))
                       (+  (aref v0 j) cost)))
            (when (and (plusp i)
                       (plusp j))
              (let ((x-i-1 (char x (1- i)))
                    (y-j-1 (char y (1- j)))
                    (val (+ (aref v* (1- j)) cost)))
                (declare (type array-index val))
                (when (and (char= x-i y-j-1)
                           (char= x-i-1 y-j)
                           (< val (aref v1 (1+ j))))
  