Dans le Système F à la Eglise, peut-on automatiser l'inférence de type pour l'élimination pour tous?

La question est la suivante. En général , quand on ont un terme comme , nous pouvons éliminer le forall en appliquant ce terme à un type, comme par exemple ( Λ X . t ) [ T ] → t [ X : = T ] .$\Lambda X.t$$(\Lambda X.t)[T]\to t[X:=T]$

Supposons maintenant que ce soit une flèche et que nous voulions lui donner un argument, alors nous aurions besoin d'appliquer ce terme au type approprié pour qu'il puisse recevoir un tel argument. Voilà ce que je demande si je peux automatiser: Est - il possible de construire une fonction en prenant deux termes et en retournant un type tel que f < Λ X . t > < r > nous donne le type à remplacer par X dans t tel que t puisse accepter l'argument r ?$f$$f<{\Lambda X.t}><{r}>$$X$$t$$t$$r$

Quelques exemples:

• .$f<{\Lambda X.\lambda x^{X\to X}.t}><{\lambda x^T.x}>=T$

• $f<{\Lambda X.\lambda x^X.r}><{(\lambda x^{R}.t^T)~s}>=T$

Je ne suis pas vraiment sûr d'avoir compris la question. Tout d'abord, j'essaie de réduire votre problème au problème d'unification suivant:

Soit un système F de type τ (X) avec une variable libre (type) X, et un type σ.
Est-il possible de trouver un type γ tel que τ (γ) = σ?

Voici un pseudo-code (avec une exception levée lorsqu'il n'est pas unifiable) pour résoudre ce problème.

unify (X, σ) = σ
unify (Y, Y) = Y
unify (τ₁ → τ₂, σ₁ → σ₂) = unify(τ₁,σ₁) → unify(τ₂,σ₂)
unify (∀Y.τ(Y), ∀Y.σ(Y)) = ∀Y.unify(τ(Y),σ(Y)) (with Y a fresh variable)
unify (_,_) = raise Not_unifiable

Vous pouvez prouver (par induction) que γ = τ (unifier (τ (X), σ) fonctionne si et seulement une exception n'est pas levée.

Maintenant, pour votre problème, vous pouvez prendre

f (ΛX.t) (r) = match type of t with "τ₁ → τ₂" => unify (τ₁, type of r) | _ => fail end

(bien sûr, votre fonction f devrait prendre comme argument un contexte si vos termes sont ouverts).