(print-struct #t)

(define-struct sum (a b) (make-inspector))
(define-struct exponent (a b) (make-inspector))
(define-struct product (a b) (make-inspector))

(define (derive expr wrt) ;wrt stands for 'with respect to'
  (cond [(sum? expr) (make-sum (derive (sum-a expr) wrt)
                               (derive (sum-b expr) wrt))]
        [(product? expr) (make-sum (make-product (derive (product-a expr) wrt)
                                                 (product-b expr))
                                   (make-product (derive (product-b expr) wrt)
                                                 (product-a expr)))]
        [(exponent? expr) (make-product (derive (exponent-a expr) wrt) 
                                        (make-product (exponent-b expr)
                                                      (make-exponent (exponent-a expr)
                                                                     (make-sum (exponent-b expr) -1))))]
        [(eq? expr wrt) 1]
        [else 0])
)

; x^2+5x+2
(define test (make-sum (make-exponent 'x 2) (make-sum (make-product 5 'x) 2)))
(printf "original expression\n")
test
(printf "the derivative\n")
(derive test 'x)

; so of course the output is sort of hard to read. i wanted to do a compactify function in recitation but the derive function took all the time

(define (pow a b)
  (if (= b 0) 1
      (* a (pow a (- b 1)))))

; then again, just looking at all this crap, i know it would have taken three recitation sessions
(define (compactify expr)
  (cond 
    [(sum? expr) (let ((compact-a (compactify (sum-a expr)))
                       (compact-b (compactify (sum-b expr))))
                      (cond [(eq? compact-a 0) compact-b]
                            [(eq? compact-b 0) compact-a]
                            [(and (number? compact-a)(number? compact-b)) 
                             (+ compact-a compact-b)]
                            [else (make-sum compact-a compact-b)]))]
    [(product? expr) (let ((compact-a (compactify (product-a expr)))
                           (compact-b (compactify (product-b expr))))
                          (cond [(eq? compact-a 1) compact-b]
                                [(eq? compact-b 1) compact-a]
                                [(or (eq? compact-a 0) (eq? compact-b 0)) 0]
                                [(and (number? compact-a)(number? compact-b)) 
                                 (* compact-a compact-b)]
                                [else (make-product compact-a compact-b)]))]
    [(exponent? expr) (let ((compact-a (compactify (exponent-a expr)))
                            (compact-b (compactify (exponent-b expr))))
                           (cond [(eq? compact-b 0) 1]
                                 [(eq? compact-b 1) compact-a]
                                 [(eq? compact-a 0) 0]
                                 [(and (number? compact-a)(number? compact-b)(integer? compact-b)) 
                                  (pow compact-a compact-b)]
                                 [else (make-exponent compact-a compact-b)]))]
    [else expr]
  )
                            
)
(printf "compactified\n")
(compactify (derive test 'x))