Gradual Typing for Objects

Siek, Jeremy G.; Taha, Walid

doi:10.1007/978-3-540-73589-2_2

Cited by 242 publications

(233 citation statements)

References 26 publications

Supporting

Mentioning

233

Contrasting

Order By: Relevance

“…This is because they imply a more flexible subtyping relationship compared to nominal subtyping, allowing unrelated classes in the class hierarchy to be subtypes. Taking this into account, some type systems [9,22,20] use structural types. In fact, a nominal type also can be considered in terms of its structural representation.…”

Section: Nominal Typesmentioning

confidence: 99%

“…With respect to type soundness, Gradualtalk follows the foundational work on gradual typing by Siek and Taha [9], with the blame assignment mechanism of Wadler and Findler [11]. The result is that Gradualtalk guarantees that, if a runtime type error occurs (that is, a MessageNotUnderstood exception is thrown), it is either due to an explicit cast that failed, or the consequence of passing an inappropriate untyped value to typed code.…”

Section: Safety and Type Soundnessmentioning

confidence: 99%

“…Subtyping of mixed types is described by the following rule: Consistent subtyping. Gradual typing extends traditional subtyping to consistent subtyping consistent subtyping [9]. Consistency, denoted ∼, is a relation that accounts for the presence of Dyn: Dyn is consistent with any other type and any type is consistent with itself.…”

Section: Subtypingmentioning

confidence: 99%

“…Integrating static and dynamic type checking is a highly active area of research. Gradual typing, defined by Siek et al [8,9], is just one of several partial typing techniques developed in the literature. Gradualtalk is based on Siek and Taha's gradual typing approach.…”

Section: Related Workmentioning

confidence: 99%

“…Gradual typing [8,9] is a partial typing technique described by Siek and Taha. It proposes a type system that allows developers to define which sections of code are statically typed and which are dynamically typed, at a very fine level of granularity, by selectively placing type annotations where desired.…”

Section: Introductionmentioning

confidence: 99%

See 4 more Smart Citations

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: Nominal Typesmentioning

confidence: 99%

Section: Safety and Type Soundnessmentioning

confidence: 99%

Section: Subtypingmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Gradual typing for Smalltalk

Allende

Callaú

Fabry

et al. 2014

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

Design and implementation of an efficient hybrid dynamic and static typing language

2014

View full text Add to dashboard Cite

Summary Dynamic languages are suitable for developing specific applications where runtime adaptability is an important issue. On the contrary, statically typed languages commonly provide better compile‐time type error detection and more opportunities for compiler optimizations. Because both approaches offer different benefits, there exist programming languages that support hybrid dynamic and static typing. However, the existing hybrid typing languages commonly do not gather type information of dynamic references at compile time, missing opportunities for improving compile‐time error detection and runtime performance. Therefore, we propose some design principles to implement hybrid typing languages that continue gathering type information of dynamically typed references. This type information is used to perform compile‐time type checking of the dynamically typed code and improve its runtime performance. As an example, we have implemented a hybrid typing language following the proposed design principles. We have evaluated the runtime performance and memory consumption of the generated code. The average performance of the dynamic and hybrid typing code is at least 2.53× and 4.51× better than the related approaches for the same platform, consuming less memory resources. Copyright © 2014 John Wiley & Sons, Ltd.

show abstract

Dynamic Flow Analysis for JavaScript

Naus

Thiemann

2019

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Static flow analyses compute a safe approximation of a program's dataflow without executing it. Dynamic flow analyses compute a similar safe approximation by running the program on test data such that it achieves sufficient coverage.We design and implement a dynamic flow analysis for JavaScript. Our formalization and implementation observe a program's execution in a training run and generate flow constraints from the observations. We show that a solution of the constraints yields a safe approximation to the program's dataflow if each path in every function is executed at least once in the training run. As a by-product, we can reconstruct types for JavaScript functions from the results of the flow analysis.Our implementation shows that dynamic flow analysis is feasible for JavaScript. While our formalization concentrates on a core language, the implementation covers full JavaScript. We evaluated the implementation using the SunSpider benchmark.

show abstract

Gradual Typing for Objects

Cited by 242 publications

References 26 publications

Gradual typing for Smalltalk

Gradual typing for Smalltalk

Design and implementation of an efficient hybrid dynamic and static typing language

Dynamic Flow Analysis for JavaScript

Contact Info

Product

Resources

About