anchor.diff:  
   ;;; Removal
   
  -; (defun remove-key (trie key &optional (count 1))
  -;   "### Remove a node from trie. If node exists, decrease it’s width.
  -;   
  -;   1. Find if key exist.
  -;   2. Decrease it's width when is less than or equal to count.
  -;   3. If width is 0, remove node into new trie to be returned."
  -;   nil)
  +(defun remove-node (trie key)
  +  (let ((node (find-key trie key)))
  +    (setf (trie-branches trie)
  +          (remove node (trie-branches trie)))
  +    node))
  +
  +(defun remove-key (trie key &optional (count 1))
  +  "### Remove a node from trie. If node exists, decrease it’s width."
  +  ; 1. Find if key exist.
  +  (let ((node (find-key trie key)))
  +    (when (and node (>= (trie-width node) count))
  +      ; 2. Decrease it's width when is less than or equal to count.
  +      (decf (trie-width node) count)
  +      ; 3. If width is 0, remove node into new trie to be returned.
  +      (when (equal 0 (trie-width node))
  +        (remove-node node key)))))
   
   ; (defun remove-key-broken (trie key)
   ;   "###"
  
positive.code: ;;; Author:
  ;;;   Peter Hillerström
  ;;; Version:
  ;;;   0.1
  ;;; Initial Common Lisp version:
  ;;;   2010-08-01
  ;;; 
  
negative.code:   TODO:
    * Use keyword arguments?
    * Implement start, end
    * 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!
            (key (pprint-pop)))
  