anchor.diff:                          ;; remove all but the expressions whose value is the same as rhs-expr
                           (remove rhs-expr (make-exprs lhs)
                             :test-not #'eql
  -                          :key #'eval))))
  +                          :key #'eval)))
                 (make-exprs rhs))))
   
   (defun make-exprs (numbers)
  
positive.code:       (loop for i from 1 to (1- (length numbers))
              for partition = (split numbers i) append 
            (loop for arg1 in (make-exprs (car partition)) append 
                (loop for arg2 in (make-exprs (cdr partition)) collect 
                  (apply-binary-ops arg1 arg2))))))
  
  (defun apply-unary-ops (arg1)
  
negative.code:   (cond ((numberp expr) (list expr))
          ((unary-p expr) expr)
          ((binary-p expr)
           (append (infix-arg (first expr) (second expr) T)
                   (cons (first expr)
                     (infix-arg (first expr) (third expr) NIL))))))
  
  (defun infix-arg (op expr lhs &aux (res (prefix-to-infix expr)))
    "Optionally add parentheses to the infix notation of EXPR, as an argument to OP."
    (if (or (not (binary-p expr))
            (precedes-p op (first expr) lhs))
        res
        (cons '[ (append res (list '])))))
  
  (defun precedes-p (op1 op2 lhs)
    "Return T if an expression of OP2 can be written without parentheses at the LHS/RHS of an expression of OP1."
    )
  
  (defun unary-p (expr)
    "Return T if EXPR is the application of a unary operator."
    (and (listp expr)
         (= (length expr) 2)
         (member (first expr) *unary-ops*)))
  
  (defun binary-p (expr)
    "Return T if EXPR is the application of a binary operator."
    (and (listp expr)
         (= (length expr) 3)
         (member (first expr) *binary-ops*)))
  
  (defun infix-to-prefix (expr)
    "Convert an infix arithmetic expression, expressed as a list of numbers, operators and brackets, into a Lisp expression."
  