anchor.diff:  ;;; Or with raw argument: 
   ;;; ("" 2 (a 2 (s 1 (T 1)) (n 1 (T 1))))
   
  -(defun print-trie (trie &optional (depth 0) (indent 2))
  -  "Traverse tries printing out nodes"
  -  (when indent (format t "~&~v@T" (* depth indent)))
  -  (format t "(~S ~d" (trie-key trie) (trie-width trie))
  -  (unless (leafp trie)
  -    (loop as branch in (trie-branches trie) do
  -      (print-trie branch (+ 1 depth) indent)))
  -  (format t ")"))
  -
  -(defun print-words (trie &optional (prefix "") start end &key (with-count))
  -  "## Prints words from the trie, one per line.
  +;; TODO Sliding window macro!
  +
  +(defun print-words (trie &optional (stream t) (prefix "")) ; start end &key (with-count))
  +  "# Prints words from the trie, one per line.
     
     Options:
     * with-count: Prints word counts after tab when over one.
  
positive.code: 
  ;;; 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-key-broken (trie key)
  ;   "###"
  
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)))
  