     (assert (not (re-find (re-pattern patt-str) "xxcd" )))
     (assert (not (re-find (re-pattern patt-str) "xxxd" )))
     (println)
-  )
-
-  ; Test array slicing functions
-  (let [tstArr [ [:a :b :c] [1 2 3] [\a \b \c]] ]
-    (assert (= (get-array-row tstArr 0) [:a :b :c] ))
-    (assert (= (get-array-row tstArr 1) [ 1  2  3] ))
-    (assert (= (get-array-row tstArr 2) [\a \b \c] ))
-    (assert (= (get-array-col tstArr 0) [:a  1 \a] ))
-    (assert (= (get-array-col tstArr 1) [:b  2 \b] ))
-    (assert (= (get-array-col tstArr 2) [:c  3 \c] ))
   )
 
   ; Match guesses

(defn to-words-by-length  
  "Maps word length to word values.  Each key is a word length. Each value is a collection
  of all words of that length.  Keys are absent if no words of that length are present."
  [word-seq]
  (group-by count word-seq) )

(defn to-word-array 
  "Returns all words of the specified length as a 2D array (vector of vectors).
  First index selects a given word, 2nd index selects chars from that word."
  [word-seq]
  (vec
    (map vec word-seq) ))

(defn num-rows
  "Given a list of words (seq of seqs), return the number of rows (1st dimension)."
  [word-list]
  (count word-list) )

(defn num-cols
  "Given a list of words (seq of seqs), return the number of columns (2nd dimension)."
  [word-list]
  (count (first word-list)) )

(defn get-array-col
  "Given a list of words (seq of seqs), return a vector of elements 
  from the specified column."
  [word-list col-idx]
  { :pre  [ (integer? col-idx) ]
    :post [] }
  (reduce #(conj %1 (nth %2 col-idx))
          [] word-list ) )

(defn get-array-row
  "Given a list of words (seq of seqs), return a vector of elements 
  from the specified row."
  [word-list row-idx]
  { :pre  [ (integer? row-idx) ]
    :post [] }
  (nth word-list row-idx) )

(defn filter-with-idx
  "Returns values from data-seq where corresponding pred-seq elements are truthy.

(defn make-guess
  "Generate the next guess letter by calculating the bits of information for each possible
  guess letter. "
  [word-list used-chars]
  (let [avail-chars   (set/difference all-letters used-chars)
        char-bits     (zipmap avail-chars (map #(calc-info-bits word-list %) avail-chars) )
        best-char     (apply max-key char-bits avail-chars) ]
    best-char ) )

