anchor.diff:  ; (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)
  +;   (unless (leafp trie)
   ;     (loop as branch in (trie-branches trie) do
   ;       (print branch)))
   ;   (format stream ")"))
   
  -(defun pprint-trie (*standard-output* trie &key (raw nil))
  +(defun pprint-trie (*standard-output* trie &key (compact t))
     "Pretty print the trie."
  -  (let ((*print-miser-width* nil))  ; Miser mode disables pprint-indent!
  -    (pprint-logical-block (*standard-output* trie :prefix "(" :suffix ")")
  +  (pprint-logical-block (*standard-output* trie :prefix "(" :suffix ")")
  +    (let ((*print-miser-width* nil)   ; Miser mode disables pprint-indent!
  +          (key (pprint-pop)))
         ; Print key
  -      (if (characterp (first trie))
  -        (write-char (pprint-pop))
  -        (write (pprint-pop)))
  +      (cond
  +        ((equal t key)    (write-char #\u2022))
  +        ((characterp key) (write-char key))
  +        (t                (write key)))
         (write-char #\Space)
  +      (pprint-indent :current 0)
  +      
         ; Print width
  -      (pprint-indent :current 0)
         (write (pprint-pop))
  +      
  +      ; Word ending
  +      (when (and compact (wordp trie))
  +        (write-char #\Space)
  +        (write-char #\u2022 #|Bullet|#))
  +      
         ; Branches
  -      (cond
  -        ((branchesp trie)
  -          ; Print list of Branches
  -          (write-char #\Space)
  -          (when *debug* (write :+))
  -          (loop as branch in (trie-branches trie) do
  -            (when *debug* (write :~))
  -            ; Word endings
  -            (unless raw
  -              (when (wordp trie)      ; FIXME Prints extra bullets
  -                (write-char #\u2022))   ; Bullet
  -              (when (leafp branch) (return-from pprint-trie)))
  -            ; THIS makes the newline after leaf!
  -            (pprint-newline :mandatory)
  -            (pprint-indent :current 0)
  -            ; Next level
  -            (pprint-trie *standard-output* branch :raw raw)
  -            ; Exit after leaf
  -            (pprint-exit-if-list-exhausted)
  -            (when *debug* (write :*)))
  -          (when *debug* (write :@)))
  -        (t ; Is leaf
  -          (when *debug* (write :%))
  -          (pprint-exit-if-list-exhausted))))))
  -
  -
  +      (let ((branches (pprint-pop)))
  +        (when branches
  +            (loop as branch in branches do
  +              (unless (equal compact (car branch))    ; Return to previous level on leaf
  +                (when *debug* (write :^))
  +                (write-char #\Space)                  ; Space before branches
  +                (unless (only-terminal-p trie)
  +                  (pprint-newline :mandatory))        ; Newline after leaf
  +                (pprint-indent :current 0)
  +                ; (pprint-exit-if-list-exhausted)
  +                (pprint-trie *standard-output* branch :compact compact)   ; Next level
  +                (when *debug* (write :*)))
  +                (when *debug* (write :$)))
  +        (pprint-exit-if-list-exhausted))))))
  +
  +
  +
  +
  +
  +
  +
  
positive.code:   * 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).
  
negative.code: (defpackage :ptrie
    (:export
      ; Predicates
      :leafp :only-terminal-p :wordp
      
      ; Init and slots
      :make-trie :trie-key :trie-width :trie-branches
  