anchor.diff:  
   ;;; Probabilities
   
  -(defun trie-prob (root suffix)
  +(defmethod trie-prob ((root trie) suffix)
     "Returns probability of suffix on given trie."
     (let ((node (obtain-seq root suffix)))
       (when node
  -      (/ (trie-width node) (trie-width root)))))
  +      (/ (width node) (width root)))))
   
   
   ;;; Sorting
  -
  -(defun sort-trie (trie predicate &key (key #'trie-key) (stable nil))
  +(defun sort-trie (trie predicate &rest args &key (key #'key) (stable nil))
     "Sort a trie recursively with a predicate function."
     (let ((root trie))
  -    (sort-trie-branch root predicate :key key :stable stable)
  +    (apply #'sort-trie-branch root predicate args)
       (unless (leafp trie)
  -      (loop as branch in (trie-branches root) do
  +      (loop as branch in (branches root) do
           (setf branch
  -              (sort-trie branch predicate :key key :stable stable))))
  +              (apply #'sort-trie branch predicate args))))
       root))
   
  -(defun sort-trie-branch (trie predicate &key (key #'trie-key) (stable nil))
  +(defun sort-trie-branch (trie predicate &key (key #'key) (stable nil))
     "Sort a trie node’s branches with a predicate function."
  -  (let ((branches (copy-list (trie-branches trie)))
  +  (let ((branches (copy-list (branches trie)))
           (sort (if stable #'stable-sort #'sort)))
  -    (setf (trie-branches trie)
  -          (funcall sort branches predicate :key key))
  +    (setf (branches trie) (funcall sort branches predicate :key key))
       trie))
   
   
  
positive.code:           (write-char +word-marker+))
      
      ; Branches
      (loop as branch in (trie-branches trie) do
        (unless (leafp branch)
          (format stream "~%") ; (write-char #\Newline)
          (bprint-trie branch stream (+ 1 depth) compact))
        (write-char #\) #|Right Paren|#))))
  
  
  
  
negative.code:     (error (format nil "Negative count ~A." count)))
    (let ((node (find-key trie key)))
      (if node
        (incf (width node) count)
        (setq node (create-node trie key count)))
      node))
  
  (defmethod create-node ((trie trie) key &optional (count 0))
    "Destructively adds node to trie"
    (car (push (make-trie :key key :width count) (branches trie))))
  
  
  ;;; Removal
  
  (defmethod remove-node ((trie trie) key)
    (let ((node (find-key trie key)))
      (setf (branches trie)
            (remove node (branches trie)))
      node))
  
  (defmethod remove-key ((trie 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 (>= (width node) count))
        ; 2. Decrease it's width when is less than or equal to count.
        (decf (width node) count)
        ; 3. If width is 0, remove node into new trie to be returned.
        (when (equal 0 (width node))
          (remove-node node key)))))
  
  ; (defun remove-seq (trie seq &optional (count 1))
  ;   "### Remove a sequence from trie"
  ;   (unless (obtain-seq trie seq)
  ;     (return-from remove-seq nil))
  ;   (decf (width trie) (max count 1))
  ;   (when (zerop (length seq))
  ;     (return-from remove-seq trie))
  ;   ; Use loop instead of recursion?
  ;   (let ((symbol (find-key trie (elt seq 0))))
  ;     (if symbol
  ;       (when (= count (width symbol))
  ;         ; Remove subtrie
  ;         (setf (branches r)
  ;             (delete #\b (branches r)
  ;             :test #'equal
  ;             :key (lambda (n) (key n))))
  ;         (remove-key trie (elt seq 0))
  ;         (return-from remove-seq nil))
  ;       (remove-seq symbol (subseq seq 1) count)))
  