(def div (fn [a b] (/ (double a) b)))

(defn evaluate [this values]
  ((:evaluate this) values))

(defn toString [this]
  (:toString this))

(defn diff [this var]
  ((:diff this) var))

(defn operation [op name diffFunc]
  (fn [& operands]
    {
     :evaluate (fn [values] (apply op (map #((:evaluate %) values) operands)))
     :toString (str "(" name " " (clojure.string/join " " (map #(:toString %) operands)) ")")
     :diff     (fn [var] (if (= (count operands) 2)
                           (diffFunc (nth operands 0) (nth operands 1) (diff (nth operands 0) var) (diff (nth operands 1) var))
                           (diffFunc (nth operands 0) (diff (nth operands 0) var))))
     }))

(declare zero)

(defn Constant [val]
  {
   :evaluate (constantly val)
   :toString (format "%.1f" val)
   :diff     (constantly zero)
   })

(def zero (Constant 0.0))
(def one (Constant 1.0))
(def two (Constant 2.0))

(defn Variable [val]
  {
   :evaluate (fn [variables] (variables val))
   :toString val
   :diff     (fn [var] (if (= val var)
                         one
                         zero))
   })

(def Add (operation + "+" (fn [_ _ da db] (Add da db))))

(def Subtract (operation - "-" (fn [_ _ da db] (Subtract da db))))

(def Multiply (operation * "*" (fn [a b da db] (Add
                                                 (Multiply da b)
                                                 (Multiply db a)))))

(def Divide (operation
              div
              "/"
              (fn [a b da db] (Divide (Subtract (Multiply b da)
                                                (Multiply a db))
                                      (Multiply b b)))))

(def Negate (operation - "negate" (fn [_ da] (Subtract da))))

(def ops
  {
   '+      Add,
   '-      Subtract,
   '*      Multiply,
   '/      Divide,
   'negate Negate
   })

(defn parse [expr]
  (cond
    (number? expr) (Constant expr)
    (symbol? expr) (Variable (str expr))
    (list? expr) (apply (ops (first expr)) (map parse (rest expr)))))

(defn parseObject [expr] ((comp parse read-string) expr))