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.

Gradual typing for Smalltalk

“…JS 0 [37] is a statically-typed version of JavaScript with inference, where both dynamic addition of fields and method updating are supported. ActionScript is one of the first languages used in the industry to embrace gradual typing, and efforts have been made to optimize it using local type inference [7]. Gradualtalk could certainly benefit from this technique.…”

“…In this context, the possibility to consolidate grown prototypes or scripts with the guarantees of a static type system is appealing. While research in combining static and dynamic typing started more than twenty years ago, recent years have seen a lot of proposals of either static type systems for dynamic languages, or partial type systems that allow a combination of both approaches [1,2,3,4,5,6,7].…”

“…Gradual typing has a strong theoretical basis and an ample design space. Industrially, it has been introduced in the ActionScript language [7].…”

Design and evaluation of gradual typing for python

“…Other research has adapted the notion of blame tracking from the work on contracts by Findler and Felleisen [11] (Siek and Wadler [28] and Wadler and Findler [35]). Rastogi et al [21] develop an approach for inferring the types of locals variables, parameters, and return types.…”

Preemptive Type Checking in Dynamically Typed Languages

“…In Gradual typing [18], type consistency (a reflective, symmetric but non-transitive relation) is used to relate Dyn with static types, and Dyn is statically consistent with any type. Gradual typing can support type inferance [19,24] and can be applied to object oriented languages [24]. Intermediaries between Dyn and static types are introduced by Flanagan [9] (Hybrid types) and by Wrigstad [23] (like types).…”