(def div #(/ (double %1) %2))
(def sqrt #(Math/sqrt (Math/abs (double %))))
(def square #(* % %))

(defn method [key]
  (fn [this & values] (if (empty? values)
                        (key this)
                        ((key this) (first values)))))

(def evaluate (method :evaluate))
(def toString (method :toString))
(def diff (method :diff))

(defn operation [op name duffFunc]
  (fn [& operands]
    {
     :evaluate (fn [values] (apply op (map #((:evaluate %) values) operands)))
     :toString (str "(" name " " (clojure.string/join " " (map #(:toString %) operands)) ")")
     :diff     (fn [var] (let [a (first operands) b (first (rest operands))]
                           (if (= (count operands) 2)
                             (duffFunc a b (diff a var) (diff b var))
                             (duffFunc a (diff a 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 Square (operation square "square" (fn [a da] (Multiply two (Multiply a da)))))

(def Sqrt (operation sqrt "sqrt" (fn [a da] (Divide (Multiply da a)
                                                    (Multiply two (Sqrt (Multiply (Square a) a)))))))

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

(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))