anchor.diff:  ;     (wrap-recursion (#'recurse-trie trie seq)
   ;         (unless symbol
   ;             (setf symbol (add-key trie (elt seq 0))))
  -;         (incf (trie-width symbol))))
  +;         (incf (trie-width symbol))))
positive.code:             (print-trie branch (+ 1 depth) :indent indent)))
      (format t ")"))
  
  (defun print-words (trie &optional order)
      "Prints words from the trie"
      nil)
  
  
  ; Macro versions of trie recursing functions - beware of bugs!
  
negative.code: ;             (return-from remove-seq nil))
  ;         (remove-seq symbol (subseq seq 1) count)))
  
  
  ;;; Probabilities
  
  (defun trie-prob (root suffix)
      "Returns probability of suffix on given trie."
      (let ((root-width (trie-width root))
            (node-width (or (trie-width (find-seq root suffix)) 0)))
          (/ node-width root-width)))
  
  
  ;;; Sorting
  
  ; TODO
  
  
  ;;; Traversal & printing
  
  (defun print-words (trie &optional (prefix "") start end &key (with-count))
      "## Prints words from the trie. Prints word counts after tab when over one.
      TODO: Use keyword arguments."
      (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
              (concatenate 'string prefix (format nil "~A" (trie-key trie)))))
      (when (equal "" (trie-key trie)) (trie-width trie)))
  
  ; (defmethod print-object ((object trie) stream)
  ;     (when *print-pretty* (format stream "~&~v@T" 2))
  ;     (format stream "(~S ~d" (trie-key trie) (trie-width trie))
  ;     (when (branchesp trie)
  ;         (loop as branch in (trie-branches trie) do
  ;             (print branch)))
  ;     (format stream ")"))
  
  (defun pprint-trie (*standard-output* trie &key (raw nil))
      "Pretty print the trie.
      
      Example of representation, for trie ROOT -> a -> (n s):
      ("" 2
          (a 2
             (s 1 •)
             (n 1 •)))
      
      With raw argument: 
      ("" 2 (a 2 (s 1 (T 1)) (n 1 (T 1))))
      "
      (setf *print-miser-width* nil)  ; Miser mode disables pprint-indent!
      (pprint-logical-block (*standard-output* trie :prefix "(" :suffix ")")
          ; Print key
  