anchor.diff:    (symbol-value (wa-boundp x)))
   
   ; XXX:
  +(defun cl-package-delimiter (x)
  +  (if (symbolp x)
  +      (let ((s (string x)))
  +        (cond ((char= (char s 0) #\:)
  +               (intern (string-upcase (string-left-trim ":" s)) "KEYWORD"))
  +              ((ppcre:scan ":" s)
  +               (let ((xs (ppcre:split ":" s)))
  +                  (intern (cadr xs) (car xs))))
  +          (t x)))
  +      x))
  +
  +(defun cl-tree (x)
  +  (cond ((not x) nil)
  +        ((consp (car x)) (cons (cl-tree (car x)) (cl-tree (cdr x))))
  +        (t (cons (cl-package-delimiter (car x)) (cl-tree (cdr x))))))
  +
  +; XXX:
   (defun wc-xdef (x &optional (y x) &rest body)
     (if (listp y)
  -      `(setf ,(wa-name x) (lambda (,@y) ,@body))
  -      (let* ((pkg (or (car body) 'cl-user))
  -             (wan (wa-name x))
  -             (cln (intern (string y) pkg)))
  +      `(setf ,(wa-name x) (lambda (,@y) ,@(cl-tree body)))
  +      (let* ((wan (wa-name x))
  +             (cln (cl-package-delimiter y)))
           (handler-case
             (cond ((macro-function  cln) `(setf ,wan (macro-function  ',cln)))
                   ((symbol-function cln) `(setf ,wan (symbol-function ',cln)))
  
positive.code:        (set-macro-character #\, 'read-comma)
         (set-macro-character #\[ 'read-bracket)
         (set-macro-character #\] (get-macro-character #\)))
  ;       (setf (elt sb-impl::*constituent-trait-table* ,(char-code #\:))
  ;             sb-impl::+char-attr-constituent+)
         ;(setf (readtable-case *readtable*) :invert)
         ,@body)
       ;(setf (readtable-case *readtable*) :upcase)
  
negative.code:         ((careq s 'if) (wc-if (cdr s) env))
          ((careq s 'fn) (wc-fn (cadr s) (cddr s) env))
          ((careq s 'assign) (wc-assign (cdr s) env))
          ((careq s 'cl) (cl-tree (cadr s)))
          ((careq s 'xdef) (apply #'wc-xdef (cdr s)))
          ((consp s) (wc-call (car s) (cdr s) env))
          (t (error "bad object in expression: ~A" s))))
  