anchor.diff:    (lambda (token)
       (if (zerop (attr token)) nil token)))
   
  -; Construct the terms of a polynomial
   (defun make-termlist (terms)
     (make-tokenlist terms))
   
  -; Construct the variables of a term
   (defun make-varlist (variables)
     (make-tokenlist variables))
   
  
positive.code:                    (make-tokenlist (cdr tokens)))
      nil))
  
  ; Construct a polynomial and simplify
  (defun make-poly (terms)
    (polyreduce (filter id (make-termlist terms))))
  
  ; Construct a term
  (defun make-term (coefficient variables)
    (term-simplify (cons coefficient
                         (list (filter id (make-varlist variables))))))
  
  ; Construct a variable
  (defun make-var (symbol power)
    (var-simplify (cons symbol power)))
  
  (defun coeff (term) (car term)) ; Term coefficient
  (defun vars (term) (cadr term)) ; Term variables
  (defun sym (var) (car var)) ; Variable symbol
  (defun pwr (var) (cdr var)) ; Variable power
  
  (defun id (val) val) ; Identity function
  
  (defun reduce (fun lst)
    (accumulate fun (car lst) (cdr lst)))
  
negative.code:              (filter (equal-fun not (car tokens)) (cdr tokens))))
        nil)))
  
  ; Whether two terms are of the same order
  (defun equal-order (fun term)
    ((equal-token vars) fun term))
  
  ; Whether two variables have the same symbol
  (defun equal-sym (fun var)
    ((equal-token sym) fun var))
  
  