A Gradual Interpretation of Union Types

We define a new, more semantic interpretation of gradual types and use it to łgradualizež two forms of polymorphism: subtyping polymorphism and implicit parametric polymorphism. In particular, we use the new interpretation to define three gradual type systems ÐHindley-Milner, with subtyping, and with union and intersection typesÐ in terms of two preorders, subtyping and materialization. These systems are defined both declaratively and algorithmically. The declarative presentation consists in adding two subsumption-like rules, one for each preorder, to the standard rules of each type system. This yields more intelligible and streamlined definitions and shows a direct correlation between cast insertion and materialization. For the algorithmic presentation, we show how it can be defined by reusing existing techniques such as unification and tallying.

Section: Related Workmentioning

confidence: 83%

Section: Related Workmentioning

confidence: 99%

Gradual typing: a new perspective

Castagna

Lanvin

Petrucciani

et al. 2019

“…The calculus does not consider blame (using cast errors instead) and their choice of operational semantics prevents the statement of a useful blame theorem. Toro and Tanter [2017] develop the idea of gradual union types, combining the advantages of tagged and untagged unions. A gradual union permits the flexibility of dynamic typing without being totally permissive: a gradual union type will statically reject some programs while the gradual type will not.…”

Section: Related Workmentioning

confidence: 99%

The root cause of blame: contracts for intersection and union types

Williams

Morris

Wadler

2018

Gradual typing has emerged as the tonic for programmers with a thirst for a blend of static and dynamic typing. Contracts provide a lightweight form of gradual typing as they can be implemented as a library, rather than requiring a gradual type system.Intersection and union types are well suited to static and dynamic languages: intersection encodes overloaded functions; union encodes uncertain data arising from branching code. We extend the untyped lambda calculus with contracts for monitoring higher-order intersection and union types, for the first time giving a uniform treatment to both. Each operator requires a single reduction rule that does not depend on the constituent types or the context of the operator.We present a new method for defining contract satisfaction based on blame behaviour. A value positively satisfies a type if applying a contract of that type can never elicit positive blame. A continuation negatively satisfies a type if applying a contract of that type can never elicit negative blame. We supplement our definition of satisfaction with a series of monitoring properties that satisfying values and continuations should have.

“…Furthermore, it has been proven that eager threesomes can be viewed as a cast-insertion implementation of the semantics prescribed by Garcia et al [2016] when applied to a gradually typed lambda calculus [Toro and Tanter 2017]. So it might generally be the case that the semantics prescribed by Garcia et al [2016] will always provide immediacy.…”

Section: Immediacymentioning

confidence: 99%

“…This is evidenced by the fact that eager threesomes [Toro and Tanter 2017] require blame tracking in order to provide accountability [Siek and Wadler 2010] even though they provide immediacy.…”

Section: Immediate Accountabilitymentioning

confidence: 99%

Sound gradual typing is nominally alive and well

Muehlboeck

Tate

2017

Recent research has identified significant performance hurdles that sound gradual typing needs to overcome. These performance hurdles stem from the fact that the run-time checks gradual type systems insert into code can cause significant overhead. We propose that designing a type system for a gradually typed language hand in hand with its implementation from scratch is a possible way around these and several other hurdles on the way to efficient sound gradual typing. Such a design process also highlights the type-system restrictions required for efficient composition with gradual typing. We formalize the core of a nominal object-oriented language that fulfills a variety of desirable properties for gradually typed languages, and present evidence that an implementation of this language suffers minimal overhead even in adversarial benchmarks identified in earlier work.