clojure's repeatedly gotcha

example.clj

(ns example)                                                                       

; This won't work.                                                                        
(defn wrong-process-lines [n action]                                               
  (letfn [(process []                                                              
           (let [ln (read-line)]                                                   
            (action ln)))]                                                         
    (repeatedly n process)))                                                       

; The dorun call is going to evaluate each item of the lazy-seq returned from the
; repeatedly call. Ergo everything will work as expected. 
(defn process-lines [n action]                                                     
  (letfn [(process []                                                              
           (let [ln (read-line)]                                                   
            (action ln)))]                                                         
    (dorun (repeatedly n process))))                                               
                                                                                   
(defn main [& args]                                                                
  (process-lines 5 println))                                                       
                                                                                   
(main)