 (defn lookup-in [lexicon {spec :spec}]
   (let [infinitive (get-in spec [:français :infinitive])
         lexemes (reduce concat (vals lexicon))]
-    (if (fail? spec)
+    (if (= :fail spec)
       (throw (Exception. (str "lookup-in was given spec=fail."))))
     (filter (fn [lexeme]
               (and

   conjugate-with. If lexicon is supplied, look up infinitive in lexicon and use exceptional form of
   first return value, if any."
  (if (nil? infinitive)
    (throw (Exception. (str "conjugate passed null infinitive.")))
    (let [diag
          (log/debug (str "conjugate: infinitive=" infinitive "; conjugate-with: "
                          (strip-refs conjugate-with)))
          exceptional-lexemes
          (lookup-in lexicon
                     {:spec (unify conjugate-with
                                   {:français {:infinitive infinitive
                                               :exception true}})})
          exceptional-surface-forms
          (map #(get-in % [:français :français])
               exceptional-lexemes)
          
          regulars
          (remove nil?
                  (map
                   (fn [replace-pattern]
                     (let [from (nth (:g replace-pattern) 0)
                           to (nth (:g replace-pattern) 1)
                           unify-against (if (:u replace-pattern)

              
            true
            (let [infinitive (get-in word [:français])
                  debug (log/debug (str "input to conjugate: infinitive: " infinitive "; spec:"
                                         (strip-refs word)))
                  synsemize ;; convert _word_ back into what (defn conjugate) can deal with.
                  (pre-conjugate {:français word})
                  result (conjugate infinitive synsemize)]
              (log/debug (str "result of conjugate: " result))
              result)))))
 
(defn fo [input &
          {:keys [from-language show-notes]
           :or {from-language nil
