 (declare find-comp-paths)
 (declare get-lexemes)
 (declare lexemes-before-phrases)
+(declare log-unification-failure)
 (declare lightning-bolts)
 (declare not-fail?)
 

                    (string/join "," (map :rule result))
                    " for: " (spec-info spec))))
    result))

               (map (fn [bolt-and-comps]
                      (let [bolt (get bolt-and-comps [])
                            paths-and-comps (dissoc bolt-and-comps [])
                            paths-to-comps (keys paths-and-comps)
                            result (reduce (fn [a b]
                                             (let [result
                                                   (cond (or (= :fail a)
                                                             (= :fail b)) :fail
                                                         true (unify a b))]
                                               (when (and (not (= :fail a)) (not (= :fail b)))
                                                 (if (= :fail result)
                                                   (log-unification-failure a b model)
                                                   (log/debug (str "unify(" ((:morph-ps model) a)
                                                                   " , " ((:morph-ps model) b) ") => "
                                                                   ((:morph-ps model) result)))))
                                               result))
                                           (cons bolt
                                                 (map (fn [path-to-comp]
                                                        (let [complement (get paths-and-comps path-to-comp)]
                                                          (assoc-in bolt path-to-comp complement)))
                                                      paths-to-comps)))]
                        (log/debug (str "generate-all: result: " ((:morph model) result)))
                        result))
                    bolt-groups)))
     (map #(do-defaults % model)) ;; for each tree, run model defaults.
     
