Corpus ID: 1570293

The Design and Implementation of Typed Scheme: From Scripts to Programs

  title={The Design and Implementation of Typed Scheme: From Scripts to Programs},
  author={S. Tobin-Hochstadt and M. Felleisen},
When scripts in untyped languages grow into large programs, maintaining them becomes difficult. A lack of explicit type annotations in typical scripting languages forces programmers to must (re)discover critical pieces of design information every time they wish to change a program. This analysis step both slows down the maintenance process and may even introduce mistakes due to the violation of undiscovered invariants. This paper presents Typed Scheme, an explicitly typed extension of PLT… Expand
1 Citations
Augmenting Type Inference with Lightweight Heuristics
It is found that polymorphism is omnipresent in object-oriented code, and that static analysis in dynamically-typed languages is also hampered by the usage of cross-hierarchy polymorphism, i.e., duck typing. Expand


Refinement types for ML
A type system called refinement types is described, which is an example of a new way to make this tradeoff, as well as a potentially useful system in itself. Expand
Advanced Macrology and the Implementation of Typed Scheme
The design and implementation of Typed Scheme is presented using the advanced language construction features of PLT Scheme's language framework and their use with a case study is demonstrated. Expand
Gradual Typing for Objects
This paper develops a gradual type system for object-based languages, extending the Ob < : calculus of Abadi and Cardelli, and shows that gradual typing and subtyping are orthogonal and can be combined in a principled fashion. Expand
Interlanguage migration: from scripts to programs
This paper proves that rewriting a program that consists of modules in the untyped lambda calculus produces an equivalent program and adds the expected amount of type safety, i.e., code in typed modules can't go wrong. Expand
Static type inference for Ruby
Diamondback Ruby (DRuby), a tool that blends Ruby's dynamic type system with a static typing discipline, is described, which believes that DRuby takes a major step toward bringing the benefits of combined static and dynamic typing to Ruby and other object-oriented languages. Expand
Gradual Typing for Functional Languages
Static and dynamic type systems have well-known strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamicExpand
Compiling polymorphism using intensional type analysis
This paper examines an alternative approach for compiling polymorphism where types are passed as arguments to polymorphic routines in order to determine the representation of an object, and shows how to translate an ML-like language into the target language so that primitive operators can analyze types to produce efficient representations. Expand
Soft typing
A generalization of static and dynamic typing---called soft typing---that combines the best features of both approaches is presented, and an extension of the ML type system supporting union types and recursive types that assigns types to a wider class of programs than ML is developed. Expand
Liquid types
We present Logically Qualified Data Types, abbreviated to Liquid Types, a system that combines Hindley-Milner type inference with Predicate Abstraction to automatically infer dependent types preciseExpand
Pluggable Type Systems
Traditionally, statically typed programming languages incorporate a built-in static type system. This system is typically mandatory: every legal program must successfully typecheck according to theExpand