A clojure implement of binary search tree

bst.clj

(ns com.example.bst)
; using {:val :left :right} as tree data structure

(defn node [val & [left right other]]
  {:val val :left left :right right :bag other})

(defn insert [parent i-node]
  (let [i-val (:val i-node)
        p-val (:val parent)
        side (cond (> i-val p-val) :left
                   (< i-val p-val) :right
                   :else nil)]
    (if side
      (assoc parent side
        (if (nil? (side parent))
          i-node
          (insert (side parent) i-node)))
      parent)
))

(defn search [node sval]
  (let [val (:val node)]
    (if node
      (cond (= val sval) node
            (> val sval) (search (:right node) sval)
            (< val sval) (search (:left node) sval)
            :else nil)
       nil)))
          
(defn n-min [node]
  (if (:right node)
    (n-min (:right node))
    (:val node)
    ))

(defn n-max [node]
  (if (:left node)
    (n-max (:left node))
    (:val node)
    ))

; test
(def root (atom (node 0 nil nil)))
(swap! root (fn [r] (insert r (node 1 nil nil))))
(swap! root (fn [r] (insert r (node -1 nil nil))))
(swap! root (fn [r] (insert r (node 2 nil nil))))
(swap! root (fn [r] (insert r (node 7 nil nil))))
(swap! root (fn [r] (insert r (node 19 nil nil))))
(swap! root (fn [r] (insert r (node -3 nil nil))))
(swap! root (fn [r] (insert r (node 22 nil nil))))
(println @root)
(println (search @root 19))
(println (n-min @root))
(println (n-max @root))