Solution to diamond kata

diamond.clj

(ns diamond
  (:require [clojure.string :as s]
            [clojure.test :refer [deftest is]]))

(defn palindrome
  [coll]
  (concat coll (reverse (butlast coll))))

(defn char-range
  [start-c end-c]
  (let [start (int start-c)
        end (int end-c)]
    (map char (range start (inc end)))))

(defn initial-coll
  [c]
  (map #(hash-map :chr %) (char-range \A c)))

(defn add-spacing
  [coll]
  (let [r (range (count coll))]
    (map #(assoc %1 :prefix %2 :suffix %3) coll (reverse r) r)))

(defn make-row
  [prefix-char suffix-char row-data]
  (let [{:keys [chr prefix suffix]} row-data]
    (->> (concat (repeat prefix prefix-char)
                 [chr]
                 (repeat suffix suffix-char))
         palindrome
         (apply str))))

(defn diamond
  [c]
  {:pre [(<= (int \A) (int c) (int \Z))]}
  (->> (initial-coll c)
       add-spacing
       (map (partial make-row " " " "))
       palindrome
       (s/join \newline)))

(deftest A
  (is (= (diamond \A) "A")))

(deftest B
  (is (= (diamond \B)
" A
B B
 A")))

(deftest C
  (is (= (diamond \C)
"  A
 B B
C   C
 B B
  A")))

(deftest E
  (is (= (diamond \E)
"    A
   B B
  C   C
 D     D
E       E
 D     D
  C   C
   B B
    A")))

(deftest input-char-not-allowed
  (is (thrown? AssertionError (diamond \a))))