anchor.diff:  
   (defun get-house-number-pattern (house-number fn)
     (dolist (number (get-house-number-sub-numbers house-number))
  -    (funcall fn (join-house-number-tokens number)
  -             (join-house-number-parse (drop-while #'(lambda (token)
  -                                                      (not (eq :number (token-type token))))
  -                                                  (parse-house-number number))))))
  +    (let ((house-number (join-house-number-tokens number))
  +          (pattern (join-house-number-parse
  +                    (drop-while #'(lambda (token)
  +                                    (not (eq :number (token-type token))))
  +                                (parse-house-number number)))))
  +      (funcall fn house-number pattern))))
   
   (defun get-house-number-strings (house-number fn)
     (dolist (number (get-house-number-sub-numbers house-number))
  
positive.code: 
     This format follows https://en.wikipedia.org/wiki/List_of_postal_codes.
    "
    (funcall fn postcode (map 'string #'(lambda (c) (cond ((latin-char-p c) #\A)
                                                          ((digit-char-p c) #\N)
                                                          ((or (char= #\- c) (char= #\. c)) #\Space)
                                                          (T c)))
                              (string-upcase postcode))))
  
  
  (defun get-phone-or-flat-pattern (phone fn)
  
negative.code:    * all digits are replaced by 'N'
     * other characters are capitalized
    "
    (let ((pattern (map 'string #'(lambda (c) (cond ((alpha-char-p c) #\A)
                                                    ((digit-char-p c) #\N)
                                                    (T c)))
                        (string-upcase phone))))
      (funcall fn phone pattern)))
  
  (defun group-by (cmp list)
    "cmp -> [a] -> [[a]]
  
     Groups equal adjacent elements of the list. Equality is checked with cmp.
    "
    (let ((buckets
             (reduce #'(lambda (buckets cur)
                         (cond ((null buckets) (cons (list cur) nil))
                               ((funcall cmp (caar buckets) cur)
                                (cons (cons cur (car buckets)) (cdr buckets)))
                               (T (cons (list cur) buckets))))
                     list :initial-value nil)))
  