Exploring the Design Space of Higher-Order Casts

Siek, Jeremy G.; García, Ronald; Taha, Walid

doi:10.1007/978-3-642-00590-9_2

Cited by 64 publications

(96 citation statements)

References 8 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…However, a higher-order cast (i.e. a cast that involves function types or, by extension, structural object types) cannot be verified immediately and therefore this check must be delayed [13,14]. This means that the point where an error is detected can be spatially and temporally decoupled from the actual source of the error.…”

Section: Blame Trackingmentioning

confidence: 99%

Gradual typing for Smalltalk

Allende

Callaú

Fabry

et al. 2014

Science of Computer Programming

View full text Add to dashboard Cite

Being able to combine static and dynamic typing within the same language has clear benefits in order to support the evolution of prototypes or scripts into mature robust programs. While being an emblematic dynamic object-oriented language, Smalltalk is lagging behind in this regard. We report on the design, implementation and application of Gradualtalk, a gradually-typed Smalltalk meant to enable incremental typing of existing programs. The main design goal of the type system is to support the features of the Smalltalk language, like metaclasses and blocks, live programming, and to accomodate the programming idioms used in practice. We studied a number of existing projects in order to determine the features to include in the type system. As a result, Gradualtalk is a practical approach to gradual types in Smalltalk, with a novel blend of type system features that accomodate most programming idioms.

show abstract

Section: Blame Trackingmentioning

confidence: 99%

Gradual typing for Smalltalk

Allende

Callaú

Fabry

et al. 2014

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…For example, consider the function 1 We infer that x and y have type Int, because the expressions on the right-hand sides have that type, and that z has type Dyn, which is the join of Int and Str. This join operation is over the subtyping lattice with Dyn as top from Siek et al [29], and always results in a type that can be safely casted to.…”

Section: Dataflow-based Type Inferencementioning

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

“…In contrast to gradual typing [3,19,26,29,30] and pluggable types [7], it introduces an intermediate step on the untyped-concretely typed spectrum and uses nominal rather than structural subtyping. Furthermore, it only requires operations to be present when actually used.…”

Section: Compile-time Optimizationsmentioning

confidence: 99%

“…Incremental typing schemes have been explored by Bracha and Griswold in Strongtalk [8] which inspired pluggable types [7], in various gradual type systems [3,19,26,29,30], and recently Typed Scheme [32,33]. In these works, dynamically typed programs can be incrementally annotated with static type information and untyped values are allowed to cross the boundary between static and dynamic code.…”

Section: Introductionmentioning

confidence: 99%

Integrating typed and untyped code in a scripting language

et al. 2010

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

Exploring the Design Space of Higher-Order Casts

Cited by 64 publications

References 8 publications

Gradual typing for Smalltalk

Gradual typing for Smalltalk

Design and evaluation of gradual typing for python

Integrating typed and untyped code in a scripting language

Contact Info

Product

Resources

About