Se me ocurrió una forma de hacer tries en Lisp, y aunque lo anoté para resolverlo cuando me despierte, no me podía dormir.

Es feo, pero funciona:

(defun find-son (tree key)
  (car (remove-if-not (lambda (x) (equal key (car x)))
                                 (cdr tree))))

(defun list-to-trie-helper (tree list)
  (unless (null list)
    (let* ((branch (find-son tree (cadr list)))
           (result (or (remove branch tree)
                       (list (car list)))))
      (append result
              (list (list-to-trie-helper
                        branch (cdr list)))))))

(defun list-to-trie (tree list)
  (list-to-trie-helper tree (cons _ list)))

Toma una lista (se supone que lo haga con strings, pero bueno…) y la transforma en un trie, con _ como nodo raíz, y los nil indican terminales.

Si agrego (T O R D E K), (P R O G R A M A) y (P R O G R A M A C I O N) a un árbol, me devolverá

(_
 (T (O (R (D (E (K NIL))))))
 (P (R (O (G (R (A (M (A NIL
                       (C (I (O (N NIL)))))))))))))

Ahora, si me disculpan, tengo que dormir.