                                                                    ))
                                                                [:sing :plur]))))
                                                      [:1st :2nd :3rd]))))
+                                           ;; TODO: why is this check disabled with (or true ..)?
                                            (cond (or true (= tense
                                                              {:synsem {:sem {:aspect :perfect
                                                                              :tense :past}}}))

                                      (map (fn [gender]
                                             (let [spec (unify/unify spec
                                                                     {:comp {:synsem {:agr gender}}})]
                                               (log/trace (str "generating from gender: " gender))
                                               (.size
                                                (map (fn [person]
                                                       (let [spec (unify/unify spec
                                                                               {:comp {:synsem {:agr {:person person}}}})]
                                                         (log/trace (str "generating from person: " person))
                                                         (.size
                                                          (map (fn [number]
                                                                 (let [spec (unify/unify spec
                                                                                         {:comp {:synsem {:agr {:number number}}}})]
                                                                   (log/debug (str "generating from spec: " spec))
                                                                   (try
                                                                     (process [{:fill-one-language
                                                                                {:count 1

                                        ;
                                                                         ;; The spec was :fail.
                                                                         (= spec :fail)
                                                                         (if true
                                                                           (log/warn (str "ignoring spec: :fail : can't generate anything from that."))
                                                                           (let [message "spec is fail!"]
                                                                             (log/error message)
                                                                             (throw (Exception. message))))
                                                                         
                                                                         ;; The verb is "funzionare" (which takes a non-human
                                                                         ;; subject), but we're trying to generate with
