     (write-lexicon "en" lexicon)
     (log/info (str "done writing lexicon."))
     (log/info (str "generating with this many verbs: " (.size (reduce concat (vals root-verbs)))))
+    ;; TODO: rewrite with threading macro (->)
     (.size (pmap (fn [verb]
                    (let [root-form (get-in verb [:english :english])]
                      (log/debug (str "generating from root-form:" root-form))

        use-map-fn map
        source-expressions (read-all spec
                                     source-language-short-name)]
    (count (use-map-fn (fn [source-expression]
                         (do (log/debug (str source-language-short-name ": " (:surface source-expression)))
                             (log/debug (str source-language-short-name ": " (get-in (:structure source-expression) [:synsem :sem])))
                             (let [spec {:synsem {:sem (strip-refs (get-in (:structure source-expression) [:synsem :sem]))}}]
                               (let [existing-english-expression (read-one spec "en")]
                                 (if existing-english-expression
                                   ;; found existing expression: return that.
                                   (do
                                     (log/info (str (:surface source-expression) " -> " (:surface existing-english-expression)))
                                     existing-english-expression)
                                   ;; else, no existing expression: generate a new one.
                                   (do
                                     (log/debug (str "generating from spec: " spec))
                                     (log/info (str "generating using source expression: '"
                                                    (:surface source-expression) "'"))
                                     (try
                                       (let [result
                                             (process [{:fill-one-language
                                                        {:count 1
                                                         :spec spec
                                                         :model small-plus-plus-np
                                                         }}]
                                                      source-language-short-name)]
                                         ;; TODO: 'result' is currently returning nil: should return something more indicative
                                         ;; of what the (process) command did.
                                         (log/debug (str "process result:" result)))
                                       (catch Exception e
                                         (let [catch-and-log-error false]
                                           (log/error (str "Could not translate source expression: "
                                                           "'" (get source-expression :surface) "'"
                                                           " from language: '" source-language-short-name 
                                                           "' with predicate: '"
                                                           (strip-refs (get-in source-expression [:structure :synsem :sem :pred]))
                                                           "' into English; subj:"
                                                           "'" (get-in source-expression [:structure :synsem :sem :subj :pred])
                                                           "'; source semantics:'"
                                                           (strip-refs (get-in source-expression [:structure :synsem :sem]))
                                                           "'" " ; exception: " e))
                                           (cond
                                             catch-and-log-error
                                             (log/info (str "ignoring above error and continuing."))
                                             true
                                             (throw e)))))))))))
                       source-expressions))))

(defn all [ & [count]]
  (let [count (if count (Integer. count) 10)

         (map (fn [lexeme-set]
                (filter (fn [lexeme]
                          (and
                           ;; for development, restrict :pred to a single value.
                           (or true (= (get-in lexeme [:synsem :sem :pred]) :talk))
                           (= (get-in lexeme [:synsem :cat]) :verb)
                           (= (get-in lexeme [:synsem :infl]) :top)
                           (not (= :top (get-in lexeme [:synsem :sem :pred] :top)))))
