                          (fn [replace-pattern]
                            (let [from (nth (:g replace-pattern) 0)
                                  to (nth (:g replace-pattern) 1)]
+                             (when (and from to infinitive)
+                               (log/debug (str "from: " from "; infinitive: " infinitive " => "
+                                               (re-matches from infinitive)))
+                               (log/debug (if (re-matches from infinitive)
+                                            (str "matched: from: " from "; infinitive: "
+                                                 infinitive " with "
+                                                 "unify-against: " (strip-refs (:u replace-pattern)) ";"
+                                                 "conjugate-with:" (strip-refs conjugate-with)))))
                              (if (and from to infinitive
                                       (re-matches from infinitive)
                                       (not (= :fail

                (log/debug (str "conjugate: infinitive=" infinitive "; conjugate-with: "
                                (strip-refs conjugate-with)))
                
                lookup-spec (strip-refs
                             (unify
                              (dissoc-paths
                               conjugate-with [[:français :exception]])
                              {:français {:infinitive infinitive
                                          :exception true}}))
                diag
                (log/debug (str "conjugate: lookup-spec: " lookup-spec))
                
                diag
                (if (= :fail lookup-spec)
                  (log/debug (str "fail-path for conjugate-with:"
                                  (strip-refs conjugate-with) "; "
                                  {:français {:infinitive infinitive

                                     prefix :prefix
                                     suffix :suffix
                                     unify-with :unify-with} %]
                                (if (not (= :fail (unify unify-with spec)))
                                  (cond (and (not (nil? prefix))
                                             (not (nil? suffix)))
                                        (str (get-in spec [:français prefix]) suffix)

                                        (not (nil? path))
                                        (get-in spec path)
                                        
                                        true (throw (Exception. (str "problem with irregular pattern:" %))))))
                             verbs/irregular-conjugations))
