                generate
                morph)))))
 
-(defn tiny-model []
-  (babel.italiano.grammar/model-plus-lexicon
-   ;; filtered lexicon:
-   (into {}
-         (for [[k lexemes] (babel.lexiconfn/read-lexicon "it")]
-           (let [filtered-lexemes
-                 (filter (fn [lexeme]
-                           (or (= k "vedere")
-                               (and (= (get-in lexeme [:synsem :cat])
-                                       :noun)
-                                    (= (get-in lexeme [:synsem :pronoun])
-                                       true))))
-                         lexemes)]
-             (if (not (empty? filtered-lexemes))
-               [k filtered-lexemes]))))
-
-   ;; filtered grammar:
-   (fn [rule]
-     (or (= (:rule rule)
-            "s-present-phrasal")
-         (= (:rule rule)
-            "vp-pronoun-nonphrasal")))))
-
-(defn test-tiny-model []
-  (let [spec {:modified false,
-              :synsem {:cat :verb, :subcat [],
-                       :sem {:pred :see,
-                             :tense :present,
-                             :aspect :simple
-                             :obj {:spec :top}}}}
-        tm (tiny-model)]
-    (repeatedly #(println (morph (time (generate spec tm)))))))
-
-
-    

        (repeatedly #(let [generated
                           (morph (generate {:synsem {:cat :verb
                                                      :subcat []}}))
                           parsed (reduce concat (map :parses (parse generated model)))]
                       (log/info (str "generated: " generated))
                       (log/info (str "semantics: "
                                      (or

             generate
             morph))))

(deftest io-lo-vedo
  (is (= "io lo vedo"
         (let [spec
