Abstracting gradual typing

García, Ronald; Clark, Alison M.; Tanter, Éric

doi:10.1145/2837614.2837670

Cited by 85 publications

(102 citation statements)

References 12 publications

Supporting

Mentioning

101

Contrasting

Order By: Relevance

“…Gradual typing is a specific way of combining dynamic and static typing in a single language, intended to create a gradual migration path from untyped to typed codebases. Since it was originally proposed by Siek and Taha [2006], gradual typing has received a lot of attention: gradual extensions have been constructed for many different type systems, the notion of blame was adapted from the world of contracts [Findler and Felleisen 2002] to track the origin of a dynamic cast failure , correctness criteria were studied [Siek et al 2015], the process of constructing a gradually-typed version of a pre-existing type system was to some extent automated [Cimini and Siek 2016;Garcia et al 2016] and last but not least, the entire approach has also been declared dead because of severe performance issues [Takikawa et al 2016].…”

Section: Related Workmentioning

confidence: 99%

Parametricity versus the universal type

Devriese

Patrignani

Piessens

2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

There has long been speculation in the scientific literature on how to dynamically enforce parametricity such as that yielded by System F. Almost 20 years ago, Sumii and Pierce proposed a formal compiler from System F into the cryptographic lambda calculus: an untyped lambda calculus extended with an idealised model of encryption. They conjectured that this compiler was fully abstract, i.e. that compiled terms are contextually equivalent if and only if the original terms were, a property that can be seen as a form of secure compilation. The conjecture has received attention in several other publications since then, but remains open to this day.More recently, several researchers have been looking at gradually-typed languages that extend System F. In this setting it is natural to wonder whether embedding System F into these gradually-typed languages preserves contextual equivalence and thus parametricity.In this paper, we answer both questions negatively. We provide a concrete counterexample: two System F terms whose contextual equivalence is not preserved by the Sumii-Pierce compiler, nor the embedding into the polymorphic blame calculus. This counterexample relies on the absence in System F of what we call a universal type, i.e., a type that all other types can be injected into and extracted from. As the languages in which System F is compiled have a universal type, the compilation cannot be fully abstract; this paper explains why.We believe this paper thus sheds light on recent results in the field of gradually typed languages and it provides a perspective for further research into secure compilation of polymorphic languages.To better explain and clarify notions, this paper uses colours, please print or view this in colours.

show abstract

Section: Related Workmentioning

confidence: 99%

Parametricity versus the universal type

Devriese

Patrignani

Piessens

2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…There has been some work in automating the shift to gradual typing [5,6,7]. We have found out that because of the particular challenge with committing to a communicating process these frameworks could not be applied.…”

Section: Related Work and (More) Future Workmentioning

confidence: 99%

Towards Gradually Typed Capabilities in the Pi-Calculus

Cimini

2019

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

Gradual typing is an approach to integrating static and dynamic typing within the same language, and puts the programmer in control of which regions of code are type checked at compile-time and which are type checked at run-time.In this paper, we focus on the π-calculus equipped with types for the modeling of input-output capabilities of channels. We present our preliminary work towards a gradually typed version of this calculus. We present a type system, a cast insertion procedure that automatically inserts run-time checks, and an operational semantics of a π-calculus that handles casts on channels. Although we do not claim any theoretical results on our formulations, we demonstrate our calculus with an example and discuss our future plans.

show abstract

“…For example, Garcia et al [2016] presented a way to create gradual type systems from static ones using techniques from abstract interpretation. The Gradualizer Siek 2016, 2017] can produce a gradual type system and dynamic semantics for a statically-typed language given its formal semantics.…”

Section: Relation To Gradual Typingmentioning

confidence: 99%

Migrating gradual types

Campora

Chen

Erwig

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Gradual typing allows programs to enjoy the benefits of both static typing and dynamic typing. While it is often desirable to migrate a program from more dynamically-typed to more statically-typed or vice versa, gradual typing itself does not provide a way to facilitate this migration. This places the burden on programmers who have to manually add or remove type annotations. Besides the general challenge of adding type annotations to dynamically typed code, there are subtle interactions between these annotations in gradually typed code that exacerbate the situation. For example, to migrate a program to be as static as possible, in general, all possible combinations of adding or removing type annotations from parameters must be tried out and compared.In this paper, we address this problem by developing migrational typing, which efficiently types all possible ways of adding or removing type annotations from a gradually typed program. The typing result supports automatically migrating a program to be as static as possible, or introducing the least number of dynamic types necessary to remove a type error. The approach can be extended to support user-defined criteria about which annotations to modify. We have implemented migrational typing and evaluated it on large programs. The results show that migrational typing scales linearly with the size of the program and takes only 2ś4 times longer than plain gradual typing.

show abstract

Abstracting gradual typing

Cited by 85 publications

References 12 publications

Parametricity versus the universal type

Parametricity versus the universal type

Towards Gradually Typed Capabilities in the Pi-Calculus

Migrating gradual types

Contact Info

Product

Resources

About