anchor.diff:          ; Predicates
           :branchesp :leafp :wordp
           
  -        ;; Init and slots
  +        ; Init and slots
           :make-trie :trie-key :trie-width :trie-branches
           
  -        ;; Insert, retrieve and remove (CRUD) operations
  +        ; Insert, retrieve and remove (CRUD) operations
           :add-seq :add-seqs
           :find-key :find-seq
           
  -        ;; Printing
  +        ; Printing
           :pprint-trie :print-words
           
  -        ;; Extras
  -        :trie-prob :test-trie
  -        )
  +        ; Extras
  +        :trie-prob :test-trie)
       (:use :cl))
   
   (in-package :ptrie)
   
  -(defparameter *print-pretty* t)
  -(defparameter *print-circle* t)
  -(defparameter *debug* nil)
  +(setq *print-pretty* t)
  +(setq *print-circle* t)
  +(setq *debug* nil)
   
   ;;; Initialization
   ;;;
  
positive.code: ;     (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
          (if (characterp (first trie))
              (write-char (pprint-pop))
              (write (pprint-pop)))
          (write-char #\Space)
          ; Print width
          (pprint-indent :current 0)
          (write (pprint-pop))
          ; Branches
          (if (branchesp trie)
              ; Has branches
              (progn
                  ; Print list of Branches
                  (write-char #\Space)
                  (when *debug* (write :+))
                  (loop as branch in (trie-branches trie) do
                      (when *debug* (write :~))
                      ; Word endings
                      (when (and (not raw) (wordp trie))
                          (write-char #\u2022)    ; Bullet
                          (return))
                      (pprint-newline :mandatory) ; THIS makes the newline after leaf!
                      (pprint-indent :current 0)
                      (pprint-trie *standard-output* branch :raw raw) ; Next level
                      (pprint-exit-if-list-exhausted)                 ; Exit after leaf
                      (when *debug* (write :*))
                      )
                  (when *debug* (write :@))
                  )
              ; Is leaf
              (progn
                  (when *debug* (write :%))
                  (pprint-exit-if-list-exhausted)))))
  
  (defun print-trie (trie &optional (depth 0) &key (indent nil))
      "Traverse tries printing out nodes"
      (when indent (format t "~&~v@T" (* depth 2)))
      (format t "(~S ~d" (trie-key trie) (trie-width trie))
      (when (leafp trie)
          (loop as branch in (trie-branches trie) do
              (print-trie branch (+ 1 depth) :indent indent)))
      (format t ")"))
  
  
  
  ; Macro versions of trie recursing functions - beware of bugs!
  ; 
  ; (defmacro wrap-recursion ((fn &rest args) &body body)
  ;     `(funcall ,fn ,@args ,@body))
  ; 
  ; (defun recurse-trie (trie seq &rest body)
  ;     "A macro to do operations on trie nodes following a sequence recursively.
  ;     Provides key, symbol and suffix in addition to arguments. Returns if sequence is 
  ;     empty, returning the current trie node. Otherwise needs a return-from form."
  ;     (if (zerop (length seq))
  ;         (return-from recurse-trie trie))
  ;     (let* ((key (elt seq 0))
  ;            (symbol (find-key trie key))
  ;            (suffix (subseq seq 1)))
  ;         (macroexpand `(,@body)) ; Might not work and even go into inf.loop when compiling!
  ;         (recurse-trie symbol suffix)))
  ; 
  ; (defun find-seq! (trie seq)
  ;     (wrap-recursion (#'recurse-trie trie seq)
  ;         (unless symbol
  ;             (return-from find-seq! nil))))
  ; 
  ; (defun add-seq! (trie seq)
  ;     (wrap-recursion (#'recurse-trie trie seq)
  ;         (unless symbol
  ;             (setf symbol (add-key trie (elt seq 0))))
  ;         (incf (trie-width symbol))))
negative.code:     (when (zerop (length seq))
          (return-from find-seq trie))
      (let ((symbol (find-key trie (elt seq 0))))
          (when symbol
              (find-seq symbol (subseq seq 1)))))
  
  (defun find-key (trie key)
  