anchor.diff:  (defun minus-terms (l)
     (cond ((empty-termlist? l) (the-empty-termlist))
   	(t
  -	 (let ((term (first-term l)))
  -	   (adjoin-term (make-term (order term)
  -				   (sub 0 (coeff term)))
  -			(minus-terms (rest-terms l)))))))
  +	 (let ((term (make-term 0 -1)))
  +	   (let ((termlist (adjoin-term term (the-empty-termlist))))
  +	     (mul-terms l termlist))))))
   
   (defun sub-terms (l1 l2)
     (add-terms l1 (minus-terms l2)))
  
positive.code: 	((equ? x (raise (project x)))
  	 (drop (project x)))
  	(t x)))
  
  (defun apply-generic (op &rest args)
    (let ((type-tags (mapcar #'type-tag args)))
      (let ((proc (my-get op type-tags)))
        (if proc
  	  (let ((res (apply proc (mapcar #'contents args))))
  	    (if (or (eq op 'add) (eq op 'sub) (eq op 'mul) (eq op 'div))
  		(drop res)
  		res))
  
  	  (let ((hig-type-tag (higher-type type-tags)))
  	    (let ((new-type-tags (mapcar #'(lambda (x) hig-type-tag) type-tags)))
  	      (if (my-get 'op new-type-tags)
  		  (let ((new-args (mapcar #'(lambda (x)
  					      (raise-to-type x hig-type-tag))
  					  args)))
  
negative.code: 
       (show (add-terms l2 l2))
       (show (mul-terms l2 l2))
  
       (show (sub-terms l2 l1))
      
  
       (let ((p1 (make-polynomial 'x l1))
  	   (p2 (make-polynomial 'x l2)))
         (show (add p1 p2))
         ;(show (sub p1 p2))
         ;(show (mul p1 p2))
         (show p1)
         (show p2))
       (show "test end")
       'done)))
  
  