anchor.diff:  ;;; Linked cons cells:  3 * cons (8 bits) = 24 bits
   ;;; Class:        16 for class, 20 for vector = 36 bits
   
  -(defstruct
  -  (trie 
  -    (:print-object bprint-trie))
  -    ; (:type list))
  -  "Trie data structure, see package documentation for more info."
  -  (key "" :read-only t)       ; Generic type -- could be :type char
  -  (width 0 :type integer)
  -  (branches nil :type list))  ; Could a vector, but it complicates things!
  +(defclass trie ()
  +  ((key
  +    :initform ""
  +    :reader key
  +    :initarg :key
  +    :type atom #|Equal to (not cons) |#
  +    ;:type character #|Could be :type char|# 
  +    :documentation "Can be any type for generality.")
  +   (width
  +    :initform 0
  +    :accessor width
  +    :initarg :width
  +    :type (integer 0 *))
  +   (branches
  +    :initform nil
  +    :accessor branches
  +    :initarg :branches
  +    :type list #|Could a vector, but it complicates things!|# ))
  +  (:documentation "Trie data structure, see package documentation for more info."))  
   
   (defun test-trie (&optional (lst *banana*))
     "Simple utility function to build a test trie."
  
positive.code: ;;;   http://en.wikipedia.org/wiki/Trie
  ;;;
  
  (in-package #:twist)
  
  (setq *print-pretty* t)
  (setq *print-circle* t)
  (setq *print-level* 12)
  
  #-sbcl
  (defparameter +word-marker+ #\+) ; SBCL + swank causes problems with UTF-8
  #+sbcl
  (defparameter +word-marker+ #\u2022) ; • Bullet
  
  (defparameter *debug* nil)
  
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)))
  