Dynamic Type Inference for Gradual Hindley--Milner Typing (1810.12619v2)

Abstract: Garcia and Cimini study a type inference problem for the ITGL, an implicitly and gradually typed language with let-polymorphism, and develop a sound and complete inference algorithm for it. Soundness and completeness mean that, if the algorithm succeeds, the input term can be translated to a well-typed term of an explicitly typed blame calculus by cast insertion and vice versa. However, in general, there are many possible translations depending on how type variables that were left undecided by static type inference are instantiated with concrete static types. Worse, the translated terms may behave differently---some evaluate to values but others raise blame. In this paper, we propose and formalize a new blame calculus $\lambda^{\textsf{DTI}}_{\textsf{B}}$ that avoids such divergence as an intermediate language for the ITGL. A main idea is to allow a term to contain type variables (that have not been instantiated during static type inference) and defer instantiation of these type variables to run time. We introduce dynamic type inference (DTI) into the semantics of $\lambda^{\textsf{DTI}}_{\textsf{B}}$ so that type variables are instantiated along reduction. The DTI-based semantics not only avoids the divergence described above but also is sound and complete with respect to the semantics of fully instantiated terms in the following sense: if the evaluation of a term succeeds (i.e., terminates with a value) in the DTI-based semantics, then there is a fully instantiated version of the term that also succeeds in the explicitly typed blame calculus and vice versa. Finally, we prove the gradual guarantee, which is an important correctness criterion of a gradually typed language, for the ITGL.

• The paper introduces lambdaRTI, a novel blame calculus that defers unbound type variable instantiation to runtime using dynamic type inference.
• It rigorously proves soundness and completeness, ensuring that dynamic inferences align with static typing to prevent blame errors.
• The approach maintains the gradual guarantee by allowing incremental type precision without introducing new runtime errors.

Dynamic Type Inference for Gradual Hindley--Milner Typing

The paper examines a type inference problem within the context of the Implicitly Typed Gradual Language (ITGL), which incorporates let-polymorphism with gradual typing principles. The authors propose a novel blame calculus, denoted $\lambdaRTI$, as an intermediate language that serves to address the incoherence issues prevalent in prior approaches to gradual typing. This calculus introduces dynamic type inference (DTI), making a significant departure from traditional static analysis paradigms.

Overview of Contributions

The primary innovation of $\lambdaRTI$ lies in integrating dynamic type inference directly into its operational semantics. The calculus defers instantiation of unbound type variables to runtime. These variables are instantiated during the evaluation process, thereby avoiding divergent behaviors typically observed in gradual typing due to differences in type variable instantiation. This approach effectively handles the complications associated with casting and type dynamics, ensuring soundness and completeness consistent with the language's operational semantics.

Technical Insights

1. Dynamic Type Inference: $\lambdaRTI$ leverages DTI to mitigate ambiguities in type instantiation. When a term contains type variables that have not been statically resolved, the calculus utilizes runtime type checking to infer and instantiate these variables. This technique assures a consistent reduction process by adapting to the dynamically available type information during evaluation.
2. Soundness and Completeness: The paper rigorously proves soundness and completeness of DTI, affirming that the approach is neither overly conservative nor erroneous. Soundness ensures that the results seen with dynamic inference are achievable through legitimate static typings, while completeness guarantees that if any static type instantiation leads to a non-blame terminating program, DTI will achieve a similar result.
3. Gradual Guarantee: $\lambdaRTI$ maintains the gradual guarantee—a critical criterion for gradual typing systems—ensuring that increasing the precision of type annotations does not introduce new runtime errors, apart from transitioning existing dynamic errors into static ones.
4. Nonparametric Semantics: The authors extend $\lambdaRTI$ to support let-polymorphism without the enforcement of full parametricity. The calculus can align with the intuitive understanding of polymorphic let-bindings, reflecting operational equivalence between $\textsf{\textup{let}\relax} \, #1{x} = w \textsf{\textup{ in }\relax} #1{f}$ and direct substitution $#1{f} [ #1{x} #1{:=} w ]$.

Implications and Future Scope

The introduction of DTI in $\lambdaRTI$ sets the stage for improved efficiency and correctness in gradually typed languages. Its successful implementation paves the way for applying similar dynamic principles to other complex typing features, including those involving subtyping and higher-rank polymorphism. The use of $\lambdaRTI$ in a practical interpreter, as discussed in the paper, demonstrates its applicability beyond theoretical constructs.

While the integration of dynamic type inference holds potential for reducing runtime overhead traditionally associated with gradually typed languages, realizing these benefits in practical implementations remains an aspect for further exploration. This paper's framework, however, offers a promising direction for languages requiring a seamless fusion of static and dynamic typing paradigms.