The behavior of gradual types: a user study

Wilson, Preston Tunnell; Greenman, Ben; Pombrio, Justin; Krishnamurthi, Shriram

doi:10.1145/3276945.3276947

Cited by 8 publications

(1 citation statement)

References 38 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Consider the following program fragment: According to standard subtype-based reasoning, the body cannot access the y field of the record. Such modular reasoning is a hallmark of static typing, and programmers who mix static and dynamic typing want to reason about their code using static types where available [Tunnell Wilson et al 2018]. Unfortunately, the following completed GTFL ≲ program compiles and runs successfully: In essence, casting q to the unknown type and then back to a record type exposes the extra field that should have been hidden by q's assumed type.…”

Section: ]mentioning

confidence: 99%

Abstracting gradual typing moving forward: precise and space-efficient

Schwerter

Clark²,

Jafery³

et al. 2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Abstracting Gradual Typing (AGT) is a systematic approach to designing gradually-typed languages. Languages developed using AGT automatically satisfy the formal semantic criteria for gradual languages identified by Siek et al. Nonetheless, vanilla AGT semantics can still have important shortcomings. First, a gradual language's runtime checks should preserve the space-efficiency guarantees inherent to the underlying static and dynamic languages. To the contrary, the default operational semantics of AGT break proper tail calls. Second, a gradual language's runtime checks should enforce basic modular type-based invariants expected from the static type discipline. To the contrary, the default operational semantics of AGT may fail to enforce some invariants in surprising ways. We demonstrate this in the GTFL ≲ language of Garcia et al. This paper addresses both problems at once by refining the theory underlying AGT's dynamic checks. Garcia et al. observe that AGT involves two abstractions of static types: one for the static semantics and one for the dynamic semantics. We recast the latter as an abstract interpretation of subtyping itself, while gradual types still abstract static types. Then we show how forward-completeness (Giacobazzi and Quintarelli) is key to supporting both space-efficient execution and reliable runtime type enforcement.

show abstract

Section: ]mentioning

confidence: 99%

Abstracting gradual typing moving forward: precise and space-efficient

Schwerter

Clark²,

Jafery³

et al. 2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

Gradual Typing Performance, Micro Configurations and Macro Perspectives

Khan,

Chen

2024

Theoretical Aspects of Software Engineering

View full text Add to dashboard Cite

Taming type annotations in gradual typing

Campora

Chen

2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Gradual typing provides a methodology to integrate static and dynamic typing, harmonizing their often conflicting advantages in a single language. When a user wants to enjoy the advantages of static typing, most gradual languages require that they add type annotations. Many nontrivial tasks must be undertaken while adding type annotations, including understanding program behaviors and invariants. Unfortunately, if this is done incorrectly then the added type annotations can be wrong–leading to inconsistencies between the program and the type annotations. Gradual typing implementations detect such inconsistencies at runtime, raise cast errors, and generate messages. However, solely relying on such error messages for understanding and fixing inconsistencies and their resulting cast errors is often insufficient for multiple reasons. One reason is that while such messages cover inconsistencies in one execution path, fixing them often requires reconciling information from multiple paths. Another is that users may add many wrong type annotations that they later find difficult to identify and fix, when considering all added annotations. Recent studies provide evidence that type annotations added during program migration are often wrong and that many programmers prefer compile-time warnings about wrong annotations. Motivated by these results, we develop exploratory typing to help with the static detection, understanding, and fixing of inconsistencies. The key idea of exploratory typing is that it systematically removes dynamic types and explores alternative types for static type annotations that can remedy inconsistencies. To demonstrate the feasibility of exploratory typing, we have implemented it in PyHound, which targets programs written in Reticulated Python, a gradual variant of Python. We have evaluated PyHound on a set of Python programs, and the evaluation results demonstrate that our idea can effectively detect inconsistencies in 98% of the tested programs and fix 93% of inconsistencies, significantly outperforming pytype, a widely used Python tool for enforcing type annotations.

show abstract

The behavior of gradual types: a user study

Cited by 8 publications

References 38 publications

Abstracting gradual typing moving forward: precise and space-efficient

Abstracting gradual typing moving forward: precise and space-efficient

Gradual Typing Performance, Micro Configurations and Macro Perspectives

Taming type annotations in gradual typing

Contact Info

Product

Resources

About