anchor.diff:  ;; See Aho, 2nd p. 152
   (defun nfa->dfa (nfa)
     "Convert an NFA to a DFA"
  -  (multiple-value-bind (i-nfa i-states i-tokens) (fa-numerize nfa)
  -    (let ((move (make-array (list (length i-states) (length i-tokens))
  -                            :initial-element nil)))
  -      ;; index moves
  -      (loop for (q0 z q1) in (fa-edges i-nfa)
  -         do (push q1 (aref move q0 z)))
  -      ;; d-states
  -      (let ((d-states (make-array 0 :adjustable t :fill-pointer t))
  -            (d-hash (make-hash-table :test #'equal))
  -            (d-edge)
  -            (mover (lambda (state token) (aref move state token))))
  -        ;; start state
  -        (vector-push-extend (nfa-e-closure (fa-start i-nfa) mover) d-states)
  -        (setf (gethash (aref d-states 0) d-hash) 0)
  -        ;; subset construction
  -        (loop for mark = 0 then (1+ mark)
  -           while (< mark (length d-states))
  -           for ds = (aref d-states mark)
  -           do (progn
  -                (loop
  -                   for i-z from 1 below (length i-tokens)
  -                   for u = (sort (nfa-move-e-closure ds i-z mover) #'<)
  -                   when u
  -                   do (progn
  -                        (when (not (gethash u d-hash))
  -                          (setf (gethash u d-hash) (length d-states))
  -                          (vector-push-extend u d-states))
  -                        (push (list mark (aref i-tokens i-z) (gethash u d-hash))
  -                              d-edge)))))
  -        ;; result
  -        (values
  -         (make-fa d-edge
  -                  (loop ; start
  -                     for q across d-states
  -                     for i from 0
  -                     when (intersection q (fa-start i-nfa))
  -                     collect i)
  -                  (loop ; accept
  -                     for q across d-states
  -                     for i from 0
  -                     when (intersection q (fa-accept i-nfa))
  -                     collect i))
  -         (loop for d across d-states
  -            collect (loop for i in d
  -                       collect (aref i-states i)))
  -         i-states
  -         i-tokens
  -         move)))))
  +  (let ((mover (fa-mover nfa)))
  +    ;; d-states
  +    (let ((d-states (make-array 0 :adjustable t :fill-pointer t))
  +          (d-hash (make-hash-table :test #'equal))
  +          (d-edge))
  +      ;; start state
  +      (vector-push-extend (nfa-e-closure (fa-start nfa) mover) d-states)
  +      (setf (gethash (aref d-states 0) d-hash) 0)
  +      ;; subset construction
  +      (loop for mark = 0 then (1+ mark)
  +         while (< mark (length d-states))
  +         for ds = (aref d-states mark)
  +         do (progn
  +              (loop
  +                 for i-z from 1 below (length (fa-tokens nfa))
  +                 for u = (sort (nfa-move-e-closure ds i-z mover) #'<)
  +                 when u
  +                 do (progn
  +                      (when (not (gethash u d-hash))
  +                        (setf (gethash u d-hash) (length d-states))
  +                        (vector-push-extend u d-states))
  +                      (push (list mark (fa-token-name nfa i-z) (gethash u d-hash))
  +                            d-edge)))))
  +      ;; result
  +      (make-fa d-edge
  +               (loop ; start
  +                  for q across d-states
  +                  for i from 0
  +                  when (intersection q (fa-start nfa))
  +                  collect i)
  +               (loop ; accept
  +                  for q across d-states
  +                  for i from 0
  +                  when (intersection q (fa-accept nfa))
  +                  collect i)))))
  +
  +
  +;; (defun dfa-minimize (dfa)
  +;;   "Give state-minimized equivalent dfa"
  +;;   (let ((succs (make-array (length (fa-states dfa)) :initial-element nil))
  +;;         (preds (make-array (length (fa-states dfa)) :initial-element nil)))
  +;;     (loop for (q0 z q1) in (fa-edges dfa)
  +;;        do (progn (push q1 (aref succs q0))
  +;;                  (push q0 (aref preds q1))))
  +;;     (labels ((partition (group &optional (remaining group))
  +;;                (let ((x (car remaining)))
  +
  +;;                (cond
  +;;                  (remaining
  +;;                   (if (subsetp (aref succs (car remaining))
  +;;                                group)
  +;;                       (partition group (cdr remaining)
  +;;                                  (cons (car remaining) group-1)
  +;;                                  group-2)
  +;;                       (partition group (cdr remaining)
  +;;                                  group-1 (cons (car remaining)
  +;;                                                group-2))))
  +;;                  ((null group-2) (list group-1))
  +;;                  ((null group-1) (list group-2))
  +;;                  (t (assert group-1)
  +;;                     (append (partition group-1)
  +;;                             (partition group-2))))))
  +;;       (append (partition (fa-accept dfa))
  +;;               (partition (set-difference (fa-states dfa)
  +;;                                          (fa-accept dfa)))))))
  +
  +
  +      ;;(map 'vector (lambda (s)
  +                     ;;(map 'list (lambda (i) (aref i-states i)) s))
  +           ;;succs))))
   
   
   ;; (defun nfa-e-close (n e-lookup)
  
positive.code:   accept
    reject)
  
  (defun make-fa (edges start accept)
    (let (states tokens)
      (map nil (lambda (x)
                 (destructuring-bind (q0 z q1) x
  
negative.code:     h))
  
  
  
  ;;; See Aho, 2nd p. 153-154. These closure computations are a
  ;;; functional variation thereof.
  