overly simple form parser

(defn form-reader [charsource]
      (loop [[c & r] (seq charsource) open-parens-count 0 out []]
            (cond 
              (= \( c)
                (recur r (inc open-parens-count) (conj out c))
              (= \) c)
                (recur r (dec open-parens-count) (conj out c))
              (and (not= 0 (count out)) (= open-parens-count 0))
                (apply str out)
              :else
                (recur r open-parens-count (conj out c)))))
 
 
(defn form-at-n [n file]
      (let [pho (fn pho [file action]
                    (try
                      (let [chunk (action file)]
                        (if chunk
                          (lazy-cons chunk (pho file action))
                          (do (.close file) nil)))
                      (catch java.io.IOException e nil)))
            rducer (fn [x y]
                       (if (not (string? x))
                         (if (= n (.getLineNumber x))
                           (let [s (form-reader (pho x #(char (.read %))))]
                             (.close x)
                             s)
                           x)
                         x))]
        (reduce rducer
                (let [f (-> file
                            java.io.File.
                            java.io.FileReader.
                            java.io.LineNumberReader.)]
                  (cons f (pho f #(.readLine %)))))))

user=> (println (form-at-n 138 "code/math.clj"))
(defn d "divisor function, totally useless" [n]
      (* 2 (apply + (map #(if (math/whole-number? (/ n %)) 1 0)
                                          (range 1 (inc (floor (sqrt n))))))))
nil
user=>