        :index (create-index grammar (flatten (vals lexicon)) head-principle)
        })))
 
-(declare against-comp)
-(declare against-pred)
-(declare matching-comp-lexemes)
-(declare matching-head-lexemes)
-
-(defn enrich [spec]
-  (let [against-pred (against-pred spec)]
-    (if true against-pred
-        (let [against-comp (map (fn [spec]
-                            (against-comp spec))
-                          (if (seq? against-pred)
-                            (seq (set against-pred))
-                            against-pred))]
-          (if (seq? against-comp)
-            (seq (set against-comp))
-            against-comp)))))
-
-(defn against-pred [spec]
-  (let [pred (get-in spec [:synsem :sem :pred] :top)]
-    (if (= :top pred)
-      spec
-      (mapcat (fn [lexeme]
-                (let [result (unify spec
-                                    {:synsem {:sem (strip-refs (get-in lexeme [:synsem :sem] :top))}}
-                                    {:synsem {:essere (strip-refs (get-in lexeme [:synsem :essere] :top))}}
-                                    )]
-                  (if (not (fail? result))
-                    (list result))))
-              (matching-head-lexemes spec)))))
-
-;; TODO: not currently used: needs to be called from within (enrich).
-(defn against-comp [spec]
-  (let [pred-of-comp (get-in spec [:synsem :sem :subj :pred] :top)]
-    (if (= :top pred-of-comp)
-      spec
-      (mapcat (fn [lexeme]
-                (let [result (unify spec
-                                    {:comp {:synsem {:agr (strip-refs (get-in lexeme [:synsem :agr] :top))
-                                                     :sem (strip-refs (get-in lexeme [:synsem :sem] :top))}}})]
-                  (if (not (fail? result))
-                    (list result))))
-              (matching-comp-lexemes spec)))))
-
-(defn matching-head-lexemes [spec]
-  (let [pred-of-head (get-in spec [:synsem :sem :pred] :top)]
-    (if (= pred-of-head :top)
-      spec
-      (mapcat (fn [lexemes]
-                (mapcat (fn [lexeme]
-                          (if (= pred-of-head
-                                 (get-in lexeme [:synsem :sem :pred] :top))
-                            (list lexeme)))
-                        lexemes))
-              (vals @lexicon)))))
-
-(defn matching-comp-lexemes [spec]
-  (let [pred-of-comp (get-in spec [:synsem :sem :subj :pred] :top)]
-    (if (= pred-of-comp :top)
-      spec
-      (mapcat (fn [lexemes]
-                (mapcat (fn [lexeme]
-                          (if (= pred-of-comp
-                                 (get-in lexeme [:synsem :sem :pred] :top))
-                            (list lexeme)))
-                        lexemes))
-              (vals @lexicon)))))
-
-(defn + [& args]
-  (parse (string/join " " args)))

      (forest/generate-all spec use-grammar
                           (flatten (vals @use-lexicon))
                           use-index))))
(declare enrich)

(def small
  (future
    (let [grammar


(require '[dag-unify.core :refer (fail? get-in strip-refs)])
(require '[babel.cache :refer [create-index]])
(require '[babel.enrich :refer [enrich]])
(require '[babel.forest :as forest])
(require '[babel.francais.grammar :refer [grammar]])
(require '[babel.francais.lexicon :refer [lexicon-source]])
