Little Schemer to Clojure translation

firsts.clj

(defn firsts [l]
    (cond (empty? l) '() 
          :else (cons (ffirst l) (firsts (rest l)))))

firsts2.clj

(defn firsts2
    ([l] 
      (firsts l '())) 
    ([l acc] 
      (cond (empty? l) (reverse acc) 
            :else (recur (rest l) (cons (ffirst l) acc)))))

insertR.clj

(defn insertR [new old lat] 
    (cond (empty? lat) '() 
          (= old (first lat)) (cons old (cons new (rest lat))) 
          :else (cons (first lat) (insertR new old (rest lat))))) 

insertR2.clj

(defn insertR2 
    ([new old lat] (insertR2 new old lat '())) 
    ([new old lat acc] (cond (empty? lat) acc 
                             (= old (first lat)) (concat (reverse (cons new (cons old acc))) (rest lat)) 
                             :else (recur new old (rest lat) (cons (first lat) acc)))))  

lat.clj

(defn lat [l]                                  
    (cond (empty? l) true                                                                                                  
          (symbol? (first l)) (lat (rest l))  
          :else false))

lat2.clj

(defn lat2 [l]                                      
    (cond (empty? l) true   
          (symbol? (first l)) (recur (rest l)) 
          :else false))

member?.clj

(defn member? [a lat]                                   
    (cond (empty? lat) false
          :else (or (= a (first lat))    
                    (member? a (rest lat)))))  

member?2.clj

(defn member2? [a lat] 
    (cond (empty? lat) false 
          :else (or (= a (first lat)) 
                    (recur a (rest lat)))))

rember.clj

(defn rember [a lat]
    (cond (empty? lat) '()
          (= a (first lat)) (rest lat) 
          :else (cons (first lat) (rember a (rest lat)))))

rember2.clj

(defn rember2 
    ([a lat] (rember a lat '())) 
    ([a lat acc] 
        (cond (empty? lat) acc 
              (= a (first lat)) (concat acc (rest lat))
              :else (recur a (rest lat) (cons (first lat) acc)))))