anchor.diff:  
   (defun only-terminal-p (node)
     "This predicate tells if node has only terminal as a child."
  -  (and (= 1 (length (trie-branches node)))
  +  (and (= 1 (length (branches node)))
          (wordp node)))
   
   
   ;;; Retrieval
   
  -(defun obtain-seq (trie seq)
  +(defmethod obtain-seq ((trie trie) (seq sequence))
     "Get a sequence from trie by following the keys in the sequence."
     (when (zerop (length seq))
       (return-from obtain-seq trie))
  
positive.code:   * Allow to specify separator insted of newline"
    
    (when (leafp trie)
      (let ((width (trie-width trie)))
        ; Print the word and count if not in '(0 1).
        ; Logand changes 1 and 0 to 0 (and changes -1 to -2, 
        ; but that’s not the point).
        (format t "~A~:[~;~10t~d~]~%" prefix (/= 0 (logand -2 width)) width))
      (return-from print-words))
    (loop as branch in (trie-branches trie) do
      (print-words branch stream
        (concatenate 'string prefix (format nil "~A" (trie-key trie)))))
    (when (equal "" (trie-key trie))
      (trie-width trie)))
  
  ; (defmethod print-object ((trie trie) stream)
  ;   ; (when *print-pretty* (format stream "~&~v@T" 2))
  ;   (format stream "(~A ~d" (trie-key trie) (trie-width trie))
  ;   (unless (leafp trie)
  ;     (loop as branch in (trie-branches trie) do
  ;       (write-char #\Space stream)
  ;       (write branch :stream stream)))
  ;   (format stream ")")
  ;   (when (leafp trie) (format stream "~%")))
  
  (defun print-trie (trie &optional (stream t) (depth 0) (indent 2))
    "## Traverse tries printing out nodes"
    (when indent (format stream "~&~v@T" (* depth indent)))
    (format stream "(~A ~d" (trie-key trie) (trie-width trie))
    (unless (leafp trie)
      (loop as branch in (trie-branches trie) do
        (print-trie branch stream (+ 1 depth) indent)))
    (format stream ")"))
  
  (defun pprint-trie (trie &optional (stream t) (compact t))
    "Pretty print the trie. Works when structure type is list."
    (pprint-logical-block (*standard-output* trie :prefix "(" :suffix ")")
      (let ((*print-miser-width* nil)   ; Miser mode disables pprint-indent!
  
negative.code:     (add-seqs r (mapcar #'(lambda (s) (string-downcase (string s))) lst))
      r))
  
  (defun make-trie (&key (key "") (width 0) branches)
    "Utility function to make a trie instance."
    (make-instance 'trie :key key :width width :branches branches))
  
  ;;; Predicates
  
  (defun leafp (node)
    "Predicate to tell if there are no branches for a node."
    (equal nil (branches node)))
  
  (defun wordp (node)
    "Predicate to tell whether this node ends any words."
  