- [let lst (list)] strikes be as being particularly non-idiomatic. I’d use () instead.

- (mapcat #(conj lst %1) s) is particularly redundant. If you want to force a seq, use (seq s). If you really need to force the issue for educational reasons, perhaps (map identity s) ?

- Of course s is a seq, so you could simplify your reduce to (reduce #(str %2 %1) s)

- Another reduce option: (reduce str (into () s) But, of course there’s no map here.

Minor nitpick: square brackets denote a vector literal in Clojure and are different to arrays (which are java mutable arrays).

You’re string reverse function is a lot more complicated than it needs to be. Here (let [lst (list)] … #(conj lst %1) …) is a long way of saying list; Note that () is also a literal for the empty list in Clojure. However, mapping list over a sequence and then concatenating the result is an identity operation on the sequence. You could just call seq on s. Lastly, because you are passing s to a seq consuming function anyway, you can elide the call to seq yourself.

This simplifies my-reverse down to:

(defn str-reverse [s] (reduce #(str %2 %) "" s)

An alternate formulation that takes advantage of lists building from the front might be

(defn str-reverse [s] (apply str (reduce conj () s)))

I think that in order to fully embrace the concept of functional programming is to use the three functions: map, reduce and filter extensively, and so I insisted on using them to tackle the problem.

Another fun variation of this is to use juxt, partial and comp:

(def palindrome? (comp (partial apply =) (juxt seq (partial reduce conj ()))))

It’s already present in librarian and in fact that’s how I work on the project.