(declare (usual-integrations))

(define (recursive-member? x u)
  (cond ((equal? x u) #t)
	((pair? u)
	 (or (recursive-member? x (car u))
	     (recursive-member? x (cdr u))))
	(else #f)))



(define (depends-on? expr var)
  (recursive-member? var expr))

(define (indep-of? expr var)
  (not (recursive-member? var expr)))


(define (new-constant)
  (generate-uninterned-symbol 'C))

(define (new-unknown)
  (generate-uninterned-symbol "U-"))



;;; Use Scmutils!

(define (derivative expr var)
  (expression
    (with-self-evaluating-unbound-variables
	(lambda ()
	  ((D (lambda->interpreted-generic-procedure
	       `(lambda (,var) ,expr)))
	   var)))))


(define (make-match the-rules)
  (define (matcher expression continue)
    (let scan ((rules the-rules))
      (if (null? rules)
	  #f
	  (or ((car rules) expression continue)
	      (scan (cdr rules))))))
  matcher)