Blame for all

Ahmed, Amal; Findler, Robert Bruce; Matthews, Jacob; Wadler, Philip

doi:10.1145/1570506.1570507

Cited by 43 publications

(76 citation statements)

References 10 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The Polymorphic Blame Calculus (λB) [1] is an explicitly polymorphic calculus with explicit casts, which is often used as a target language for gradual type systems with polymorphism. In λB a notion of compatibility is employed to validate conversions allowed by casts.…”

Section: Introductionmentioning

confidence: 99%

Consistent Subtyping for All

Xie

Oliveira

2018

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. Consistent subtyping is employed in some gradual type systems to validate type conversions. The original definition by Siek and Taha serves as a guideline for designing gradual type systems with subtyping. Polymorphic typesà la System F also induce a subtyping relation that relates polymorphic types to their instantiations. However Siek and Taha's definition is not adequate for polymorphic subtyping. The first goal of this paper is to propose a generalization of consistent subtyping that is adequate for polymorphic subtyping, and subsumes the original definition by Siek and Taha. The new definition of consistent subtyping provides novel insights with respect to previous polymorphic gradual type systems, which did not employ consistent subtyping. The second goal of this paper is to present a gradually typed calculus for implicit (higher-rank) polymorphism that uses our new notion of consistent subtyping. We develop both declarative and (bidirectional) algorithmic versions for the type system. We prove that the new calculus satisfies all static aspects of the refined criteria for gradual typing, which are mechanically formalized using the Coq proof assistant.

show abstract

Section: Introductionmentioning

confidence: 99%

Consistent Subtyping for All

Xie

Oliveira

2018

Programming Languages and Systems

View full text Add to dashboard Cite

show abstract

“…This is a design decision. Nothing prevents adding blame control to like types in accordance with previous work (e.g., [1,27]). The rationale for our design is to avoid performance penalties.…”

Section: Compile-time Optimizationsmentioning

confidence: 88%

Integrating typed and untyped code in a scripting language

Wrigstad

Nardelli

Lebresne

et al. 2010

Proceedings of the 37th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Many large software systems originate from untyped scripting language code. While good for initial development, the lack of static type annotations can impact code-quality and performance in the long run. We present an approach for integrating untyped code and typed code in the same system to allow an initial prototype to smoothly evolve into an efficient and robust program. We introduce like types, a novel intermediate point between dynamic and static typing. Occurrences of like types variables are checked statically within their scope but, as they may be bound to dynamic values, their usage is checked dynamically. Thus like types provide some of the benefits of static typing without decreasing the expressiveness of the language. We provide a formal account of like types in a core object calculus and evaluate their applicability in the context of a new scripting language.

show abstract

“…Dynamic typing lends itself well to a generic style of programming, and thus it is no surprise that many of the functions and portions of code that we could not assign static types to would by much more typable if our type system provided generics. Nearfuture work will involve implementing such types, possibly as an adaptation of Ahmed et al [3].…”

Section: Classifying Statically Untypable Codementioning

confidence: 99%

Design and evaluation of gradual typing for python

et al. 2014

View full text Add to dashboard Cite

Combining static and dynamic typing within the same language offers clear benefits to programmers. It provides dynamic typing in situations that require rapid prototyping, heterogeneous data structures, and reflection, while supporting static typing when safety, modularity, and efficiency are primary concerns. Siek and Taha (2006) introduced an approach to combining static and dynamic typing in a fine-grained manner through the notion of type consistency in the static semantics and run-time casts in the dynamic semantics. However, many open questions remain regarding the semantics of gradually typed languages.In this paper we present Reticulated Python, a system for experimenting with gradual-typed dialects of Python. The dialects are syntactically identical to Python 3 but give static and dynamic semantics to the type annotations already present in Python 3. Reticulated Python consists of a typechecker and a source-to-source translator from Reticulated Python to Python 3. Using Reticulated Python, we evaluate a gradual type system and three approaches to the dynamic semantics of mutable objects: the traditional semantics based on Siek and Taha (2007) and Herman et al. (2007) and two new designs. We evaluate these designs in the context of several third-party Python programs.

show abstract

Blame for all

Cited by 43 publications

References 10 publications

Consistent Subtyping for All

Consistent Subtyping for All

Integrating typed and untyped code in a scripting language

Design and evaluation of gradual typing for python

Contact Info

Product

Resources

About