      {(get-in (first phrases) [:rule])
       {:comp
        (filter (fn [lex]
-                 (not (fail? (unifyc (first phrases)
+                 (not (fail? (unify (first phrases)
                                      {:comp lex}))))
                lexicon)
 
        :comp-phrases
        (filter (fn [comp-phrase]
-                 (not (fail? (unifyc (first phrases)
+                 (not (fail? (unify (first phrases)
                                      {:comp comp-phrase}))))
                all-phrases)
 
        :head-phrases
        (filter (fn [head-phrase]
-                 (not (fail? (unifyc (first phrases)
+                 (not (fail? (unify (first phrases)
                                      {:head head-phrase}))))
                all-phrases)
 
        :head
        (filter (fn [lex]
                  (log/debug (str "trying lexeme: " lex))
-                 (not (fail? (unifyc (first phrases)
+                 (not (fail? (unify (first phrases)
                                      {:head lex}))))
                lexicon)}}
      (build-lex-sch-index (rest phrases) lexicon all-phrases))))

  (cond (seq? spec)
        (map show-spec spec)
        true
        (remove-top-values-log (dissoc-paths spec '((:english :initial)
                                                    (:italiano :initial)
                                                    (:synsem :essere)
                                                    (:synsem :agr)
                                                    (:synsem :pronoun)
                                                    (:synsem :sem :tense)
                                                    (:synsem :sem :obj :tense)
                                                    (:synsem :sem :mod)
                                                    (:synsem :infl))))))

(defn map-subset-by-path2 [vals-at-path lexemes path]
  (if (not (empty? vals-at-path))

    (conj (build-lex-sch-index grammar
                               (map (fn [lexeme]
                                      (log/debug (str "trying(ci) lexeme: " lexeme))
                                      (unify lexeme
                                              {:phrasal false}))
                                    lexicon)
                               grammar)
