                 )]
     suffix))
 
+(defn analyze [surface-form lookup-fn]
+  "return the map incorporating the lexical information about a surface form..."
+  (lookup-fn surface-form))
+

        last-stem-char-is-e (re-find #"er$" infinitive)
                 person (get-in word '(:agr :person))
        number (get-in word '(:agr :number))
        g-stem (re-find #"[g]er$" infinitive)]
    (cond
     ;;
     ;; conjugate irregular passato: option 1) using :passato-stem
     (and (= :past (get-in word '(:infl)))
          (get-in word '(:passato-stem)))
     (let [irregular-passato (get-in word '(:passato-stem))]
       (str irregular-passato (suffix-of word)))

     ;; conjugate irregular passato: option 2) using :passato
     (and (= :past (get-in word '(:infl)))
          (get-in word '(:passato)))
     (let [irregular-passato (get-in word '(:passato))
           butlast (nth (re-find #"(.*).$" irregular-passato) 1)]
       (str butlast (suffix-of word)))

     ;; conjugate regular passato
     (= :past (get-in word '(:infl)))
     {:infinitive infinitive
      :er-type er-type
      :ir-type ir-type
      :re-type re-type
      :g-stem g-stem})))

;; TODO: this is an overly huge method that needs to be rewritten to be easier to understand and maintain.
;; TODO: lots of redundant code with other languages than French: refactor.


           (= true (get-in word [:exception]))
           (get-in word [:français])

           (and
            (= (get-in word '(:infl)) :past))
           (passe-compose word)
           
           (and
            (= (get-in word '(:infl)) :present)
            (string? (get-in word '(:français))))
           (present word)

           (and
            (= (get-in word '(:infl)) :futuro)
            (string? (get-in word '(:français))))
           (future word)

           (and
            (= (get-in word '(:infl)) :conditional)
            (string? (get-in word '(:français))))
           (conditional word)
              
           ;;QUI COMINCIA L’ IMPERFETTO
           (and
            (= (get-in word '(:infl)) :imperfetto)
            (string? (get-in word '(:français))))
           (imperfect word)
           
           (and
            (get-in word '(:a))
