anchor.diff:      (setq ,name
         (make-tree-transform :placeholders ,placeholders
                              :match ,match
  -			   :conversion #'((&key ,@(cadr placeholders))
  -					 ,conversion)))
  +			   :conversion #'((&key ,@.placeholders.)
  +					            ,conversion)))
       (tree-transform-compile ,name)))
   
   (defun tree-transform-conversion-args (trn)
  
positive.code:    match."
    ; Match cons.
    (let form (make-queue)
      (do ((m match (cdr m)))
          ((endp m) (queue-list form))
        (let mcar (car m)
          (cond
            ((eq mcar '*rest)	; Rest of current list.
              (enqueue form
                `(progn
                   (push (cons ',(cadr m) e) (tree-transform-clips trn))
                   (return t)))
              (return-from tree-transform-compile-r (queue-list form)))
  
            ; Take element if match is a placeholder.
            ((member mcar (tree-transform-placeholders trn))
              (enqueue form `(push (cons ',mcar (car e)) (tree-transform-clips trn))))
  
            (t
              ; If any of the elements is a cons, the match fails.
              (? (cons? mcar)
                (awhen (tree-transform-compile-r mcar trn)
                  (enqueue form '(cons? (car e)))
                  (enqueue form `(#'((e) (block nil (& ,@!))) (car e))))
                (? (number? mcar)
                  (enqueue form `(== (car e) ,mcar))
                  (enqueue form `(eq (car e) ',mcar))))))
  
          ; If next is an any match, return its first element or T.
          (when (& (cdr m) (eq (cadr m) '*any))
            (enqueue form '(? (cdr e) (cdr e) t))
            (return-from tree-transform-compile-r (queue-list form)))
  
          ; Return T if end of lists match.
          (? (not (cdr m))
            (progn
              (enqueue form '(not (cdr e)))
              (return-from tree-transform-compile-r (queue-list form)))
            (enqueue form '(setq e (cdr e))))))))
  
  (defun tree-transform-compile (trn)
    "Match a pattern and return first toplevel cons after match."
  
negative.code:   (let form (tree-transform-compile-r (tree-transform-match trn) trn)
      (= (tree-transform-compiled-match trn)
        (eval (macroexpand `#'((e trn)
                                 (& ,@form)))))))
  
  (defun tree-transform! (trn e)
    (when (cons? e)
  