Monotonic References for Efficient Gradual Typing

Siek, Jeremy G.; Vitousek, Michael M.; Cimini, Matteo; Tobin-Hochstadt, Sam; García, Ronald

doi:10.1007/978-3-662-46669-8_18

Cited by 48 publications

(58 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The particular style of RTTI-based gradual typing developed for Safe TypeScript is reminiscent of prior proposals by Swamy et al (2014) and Siek and Vitousek (2013), but makes important improvements over both. Whereas prior approaches require all heap-allocated values to be instrumented with RTTI (leading to a significant performance overhead, as discussed in §5), in Safe TypeScript RTTI is added to objects only as needed.…”

Section: A New Style Of Efficient Rtti-based Gradual Typingmentioning

confidence: 99%

“…As such, the copy function and the statically typed field accesses circ.center.x are compiled unchanged. The freshly allocated object literal {x:0,y:0} is inferred to have type Point and is also unchanged (in contrast to Swamy et al (2014) and Siek and Vitousek (2013), who instrument all objects with RTTI). We insert checks only at the boundaries between static and dynamically typed code and within dynamically typed code, as detailed in the 4 steps below.…”

Section: A New Style Of Efficient Rtti-based Gradual Typingmentioning

confidence: 99%

“…Prior work on RTTI-based gradual typing suggests tagging every object, as soon as it is allocated (cf. Vitousek 2013 andSwamy et al 2014). Following their approach, our initial implementation of Safe TypeScript ensured that every object carries a tag.…”

Section: Differential Subtypingmentioning

confidence: 99%

See 2 more Smart Citations

Safe & Efficient Gradual Typing for TypeScript

et al. 2015

View full text Add to dashboard Cite

Current proposals for adding gradual typing to JavaScript, such as Closure, TypeScript and Dart, forgo soundness to deal with issues of scale, code reuse, and popular programming patterns. We show how to address these issues in practice while retaining soundness. We design and implement a new gradual type system, prototyped for expediency as a 'Safe' compilation mode for TypeScript. Our compiler achieves soundness by enforcing stricter static checks and embedding residual runtime checks in compiled code. It emits plain JavaScript that runs on stock virtual machines. Our main theorem is a simulation that ensures that the checks introduced by Safe TypeScript (1) catch any dynamic type error, and (2) do not alter the semantics of type-safe TypeScript code. Safe TypeScript is carefully designed to minimize the performance overhead of runtime checks. At its core, we rely on two new ideas: differential subtyping, a new form of coercive subtyping that computes the minimum amount of runtime type information that must be added to each object; and an erasure modality, which we use to safely and selectively erase type information. This allows us to scale our design to full-fledged TypeScript, including arrays, maps, classes, inheritance, overloading, and generic types. We validate the usability and performance of Safe TypeScript empirically by type-checking and compiling around 120,000 lines of existing TypeScript source code. Although runtime checks can be expensive, the end-to-end overhead is small for code bases that already have type annotations. For instance, we bootstrap the Safe TypeScript compiler (90,000 lines including the base TypeScript compiler): we measure a 15% runtime overhead for type safety, and also uncover programming errors as type safety violations. We conclude that, at least during development and testing, subjecting JavaScript/TypeScript programs to safe gradual typing adds significant value to source type annotations at a modest cost.

show abstract

Section: A New Style Of Efficient Rtti-based Gradual Typingmentioning

confidence: 99%

Section: A New Style Of Efficient Rtti-based Gradual Typingmentioning

confidence: 99%

See 1 more Smart Citation

Safe & Efficient Gradual Typing for TypeScript

et al. 2015

View full text Add to dashboard Cite

show abstract

“…Another approach used by Vitousek et al [2014] in Reticulated Python, and by Swamy et al [2014] and Rastogi et al [2015] in Safe TypeScript, is what Siek et al [2015b] formalized as the monotonic approach. Here, every value keeps track of what type it has been checked to have, and enforces that type in later mutations.…”

Section: Transient the Transient Cast Semantics Was Proposed Bymentioning

confidence: 99%

“…One potential solution to overcoming this barrier is to adapt the existing work on monotonic references [Siek et al 2015b;Swamy et al 2014;Vitousek et al 2014] to assign nominal type-tags to objects. A question that needs to be resolved here is whether additional type specialization should be allowed to happen after the first tag has been added, as this is not something one would expect from a nominal type system.…”

Section: Interacting With Structuralmentioning

confidence: 99%

Sound gradual typing is nominally alive and well

Muehlboeck

Tate

2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

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.

show abstract

Pragmatic Gradual Polymorphism with References

Oliveira

2023

Programming Languages and Systems

View full text Add to dashboard Cite

Gradualizing System F has been widely discussed. A big challenge is to preserve relational parametricity and/or the gradual guarantee. Most past work has focused on the preservation of parametricity, but often without the gradual guarantee. A few recent works satisfy both properties by giving up System F syntax, or with some restrictions and the introduction of sophisticated mechanisms in the dynamic semantics.While parametricity is important for polymorphic languages, most mainstream languages typically do not satisfy it, for a variety of different reasons. In this paper, we explore the design space of polymorphic languages that satisfy the gradual guarantee, but do not preserve parametricity. When parametricity is not a goal, the design of polymorphic gradual languages can be considerably simplified. Moreover, it becomes easy to add features that are of practical importance, such as mutable references. We present a new gradually typed polymorphic calculus, called $$\lambda ^{G}_{gpr}$$ λ gpr G , with mutable references and with an easy proof of the gradual guarantee. In addition, compared to other gradual polymorphism work, $$\lambda ^{G}_{gpr}$$ λ gpr G is defined using a Type-Directed Operational Semantics (TDOS), which allows the dynamic semantics to be defined directly instead of elaborating to a target cast language. $$\lambda ^{G}_{gpr}$$ λ gpr G and all the proofs in this paper are formalized in Coq.

show abstract

Monotonic References for Efficient Gradual Typing

Cited by 48 publications

References 15 publications

Safe & Efficient Gradual Typing for TypeScript

Safe & Efficient Gradual Typing for TypeScript

Sound gradual typing is nominally alive and well

Pragmatic Gradual Polymorphism with References

Contact Info

Product

Resources

About