           (if (string? result)
             (trim result)
             result))
-        
+
         ;; je + aime = j'aime
         (and (not (nil? b))
              (not (nil? (get-string b)))

          (log/debug (str "word's :a french is a string? " (get-in word '(:a :français)) " => " (string? (get-in word '(:a :français)))))

          (cond
           (= word :top) ".."
           
           (ref? word)
           (get-string @word)
           
           ;; TODO: this is a special case that should be handled below instead
           ;; of forcing every input to go through this check.
           (= word {:initial false})
           ".."
           (= word {:initial true})
           ".."
           
           (and (string? (get-in word '(:a)))
                (string? (get-in word '(:b))))
           (get-string (get-in word '(:a))
                       (get-in word '(:b)))
           
           (and (string? (get-in word '(:a)))
                (map? (get-in word '(:b))))
           (get-string (get-in word '(:a))
                       (get-in word '(:b)))
           
           (and (map? (get-in word '(:a)))
                (map? (get-in word '(:b))))
           (get-string
            (get-in word '(:a))
            (get-in word '(:b)))
           
           ;; TODO: this rule is pre-empting all of the following rules
           ;; that look in :a and :b. Either remove those following rules
           ;; if they are redundant and not needed, or move this general rule
           ;; below the following rules.
           (and (not (= :none (get-in word '(:a) :none)))
                (not (= :none (get-in word '(:b) :none))))
           (get-string (get-in word '(:a))

        ;; (elle) la + est (amuseé) = (elle) l'est (amuseé)
        (and (not (nil? b))
             (let [a (get-string word)
                   b-str (get-string b)
                   debug (if (nil? b-str)
                           (throw (Exception. (str "get-string=nil for b: " (strip-refs b)))))
                   b b-str]
               (and (re-find #"^(la|le|me|se|te)$" a) ;;
                    (re-find #"^[aeéiou]" b))))
        (let [a (get-string word)]
