anchor.diff:             (dispatch-reference primary modifiers))
            (`(conditional (,op ,left ,right) ,then ,else)
              (import-conditional op left right then else))
  +         (`(inversion ,form)
  +           (import-inversion form))
  +         (`(conditional ,test ,then)
  +           (import-bool-when test then))
  +         (`(conditional ,test ,then ,else)
  +           (import-bool-if test then else))
            (`(conditional (,op ,left ,right) ,then)
              (import-conditional op left right then nil))
            (`(negation ,expr) `(- ,(import-form expr)))
  
positive.code:     (or (find-symbol name :varjo)
          (intern name))))
  
  (defvar *binary-op-lookup*
    '((addition . +)
      (subtraction . -)
      (division . /)
      (multiplication . *)
      (modulus . mod)
      (left-shift . foo)
      (right-shift . foo)
      (less-than . <)
      (greater-than . >)
      (less-equal-than . <=)
      (greater-equal-than . >=)
      (equal . ==)
      (not-equal . !=)
      (bitwise-and . foo)
      (exclusive-or . foo)
      (inclusive-or . foo)
      (logical-and . foo)
      (logical-xor . foo)
      (logical-or . foo)))
  
  (defun import-binary-operator (form)
    (dbind (op left right) form
  
negative.code:     ;; (logical-or)
      ))
  
  (defun import-bool-when (test then)
    `(when ,(import-form test)
       ,(import-form then)))
  
  (defun import-bool-if (test then else)
    `(if ,(import-form test)
         ,(import-form then)
         ,(import-form else)))
  
  (defun import-inversion (form)
    `(not ,(import-form form)))
  
  (defun import-conditional (op left right then else)
    (if else
        `(if (,(cdr (assoc op *ops*)) ,(import-form left) ,(import-form right))
  