#lang racket

(struct const    (val)      #:transparent)
(struct op       (symb l r) #:transparent)
(struct variable (x)        #:transparent)
(struct df       (∂ f)      #:transparent)


(define (∂ f)
  (match f
    [(const n)   (const 0)]
    [(variable x)  (const 1)]
    [(op '+ f g) (op '+ (∂ f) (∂ g))]
    [(op '* f g) (op '+ (op '* (∂ f) g)
                        (op '* f (∂ g)))]))



(define (eval e val)
  (match e
    [(const n) n]
    [(variable x) val]
    [(op '+ l r) (+ (eval l val) (eval r val))]
    [(op '* l r) (* (eval l val) (eval r val))]
    [(df '∂ f) (eval (∂ f) val)]
    ))

(define (expr? e)
  (match e
    [(const n) (number? n)]
    [(variable x) (symbol? x)]
    [(df ∂ f) (and (eq? ∂ '∂) (expr? f))]

    [(op s l r) (and (member s '(+ *))
                     (expr? l)
                     (expr? r))]
    [_ false]))


(define e1 (op '* (op '+ (const 2) (const 2))
                  (const 2)))

(define x 3)

(define e2 (df '∂ (op '* (variable x) (variable x))))

(define e3 (op '+ (op '* (variable x) (const 2)) (df '∂ (op '+ (op '* (variable x) (variable x))
                                                           (variable x)))))

(set! x 5)

(define e4 (op '+ (const 2) (variable x)))

(eval e1 1)
(eval e2 1)
(eval e3 1)
(eval e4 1)