                                lt-clauses
                                (conj lt-clauses lt-clause))])) [implicit-types []] targs)]
     (when-not (empty? remaining-implicit-types)
-      (throw (ex-info "Unsolved implicit type parameters" {:definition def-name
+      (throw (ex-info "Unsolved implicit type parameters" {:statement def-name
                                                            :implicit-type-params implicit-types
                                                            :unsolved remaining-implicit-types})))
     `(defimplicit ~def-name

                   (definition ~explicit-def-name ~(str "This is an explicit variant of [[" def-name "]].") ~new-params ~body)
                   ~(gen-type-parameters-defimplicit def-name "Definition" doc explicit-def-name implicit-types params new-params body)
                   (alter-meta! (var ~def-name) update-in [:arglists] (fn [_#] (list (quote ~params))))
                   [:defined :term (quote ~def-name)]))
          ;; no implicit parmeter types from here...
          (let [[status definition] (handle-term-definition def-name params body)]
            (when (= status :ko)
              (throw (ex-info "Cannot define term." {:name def-name, :error definition})))
            ;;{
            ;;  - Second, after some checks, we register the definition in the currently active namespace (i.e. `*ns*`).
            ;;}          

      (throw (ex-info "Cannot define term: syntax error."
                      {:explain (s/explain-str ::definition args)}))
      (let [{def-name :name doc :doc params :params body :body} conf-form]
        ;; handling of implicit parameter types
        (if-let [res (u/fetch-implicit-type-parameters params)]
          (let [{implicit-types :implicit-types new-params :new-params} res
