The ins and outs of gradual type inference

Abstract

Gradual typing lets programmers evolve their dynamically typed programs by gradually adding explicit type annotations, which confer benefits like improved performance and fewer run-time failures.However, we argue that such evolution often requires a giant leap, and that type inference can offer a crucial missing step. If omitted type annotations are interpreted as unknown types, rather than the dynamic type, then static types can often be inferred, thereby removing unnecessary assumptions of the dynamic type. The remaining assumptions of the dynamic type may then be removed by either reasoning outside the static type system, or restructuring the code.We present a type inference algorithm that can improve the performance of existing gradually typed programs without introducing any new run-time failures. To account for dynamic typing, types that flow in to an unknown type are treated in a fundamentally different manner than types that flow out. Furthermore, in the interests of backward-compatibility, an escape analysis is conducted to decide which types are safe to infer. We have implemented our algorithm for ActionScript, and evaluated it on the SunSpider and V8 benchmark suites. We demonstrate that our algorithm can improve the performance of unannotated programs as well as recover most of the type annotations in annotated programs.

TypeDevil: Dynamic Type Inconsistency Analysis for JavaScript

“…For example, [15] perform 226 refactorings and add 177 type annotations to reduce false positives, which eventually leads to the discovery of 8 errors; [22] find that up to 39% of the checked code violates type properties (for the deltablue benchmark, which has one warning from TypeDevil). Optimizing JIT compilers benefit from inferred types to emit type-specialized code [20], [24], [36]. Ahn et al [3] improve the object representation to enable optimizations even though objects with different prototypes appear at a single code location.…”

“…TypeDevil has a relatively low number of false positives because it uses a mostly dynamic analysis, because it focuses on individual problematic code locations instead of inferring sound types for the entire program, and because it uses a set of novel techniques to deal with intentionally polymorphic code. Second, optimizing JIT compilers leverage static and dynamic type inference to emit code specialized towards particular runtime types [20], [24], [36]. Instead of improving the performance of existing programs, TypeDevil warns developers about problematic code locations.…”

Migrating gradual types

“…From this perspective, our type system studies the combination of variational types and gradual types. Gradual languages with type inference [Garcia and Cimini 2015;Rastogi et al 2012;Siek and Vachharajani 2008] were a large influence on migrational typing. While ITGL was used as the basis for formalizing our type system, we expect that our approach can be extended to handle other features in this line of work.…”

“…Gradual type inference with flow-based typing [Rastogi et al 2012] has been explored to make programs in dynamic object-oriented languages more performant. Since our work is formalized on ITGL, our work inherits the relations between ITGL and the flow-based inference [Garcia and Cimini 2015].…”

Tackling the efficiency problem of gradual typing

“…Other approaches include the work of Rastogi et al. [10], using local type inference to significantly reduce the number of casts that are required; the work of Herman et al [7], in which they propose to use coercions instead of proxies in a chain of higher-order cast, so as to be able to combine adjacent coercions in order to limit space consumption; the work of Siek et al [13], in which they go a step further, developing threesomes as a data structure and algorithm to represent and normalize coercions. A threesome is a cast with three positions: source, target, and an intermediate lowest type.…”