• Corpus ID: 5088113

Types and programming languages

  title={Types and programming languages},
  author={Benjamin C. Pierce},
A type system is a syntactic method for automatically checking the absence of certain erroneous behaviors by classifying program phrases according to the kinds of values they compute. [] Key Method Each chapter is accompanied by numerous exercises and solutions, as well as a running implementation, available via the Web. Dependencies between chapters are explicitly identified, allowing readers to choose a variety of paths through the material.The core topics include the untyped lambda-calculus, simple type…

A Tutorial on Type Theory, Foundations of Programming Languages, and Formal Verification

This paper focuses on the design, analysis and study of type systems, a logical formalism used extensively in the study and design of programming languages to define the semantics and behavior of deductive systems.

Combining Proofs and Programs

A work-in-progress overview of the Trellys project, which is new core language, designed to provide a smooth path from functional programming to dependently-typed programming, and allows programmers to work with total and partial functions uniformly.

Programming with Types

This dissertation investigates the foundations of run-time type analysis in the context of statically-typed, polymorphic programming languages to show how such a language may support type-analyzing operations in a way that balances expressiveness, safety and simplicity.

An Integrated Theory of Type-Based Static and Dynamic Verification

This thesis focuses on three universal features in programming: delimited control, parametric polymorphism, and algebraic datatypes, and examines how these features are incorporated with mechanisms for integrating a certified and an uncertified worlds, based on gradual typing.

Dependent types for safe systems software

Deputy is presented, a dependent type framework that allows programmers to annotate existing C code with more refined types and is shown how it can be instantiated to support the dependent types required by modern systems code.

Advanced Topics In Types And Programming Languages

Topics covered include precise type analyses, which extend simple type systems to give them a better grip on the run time behavior of systems; type systems for low-level languages; applications of types to reasoning about computer programs; type theory as a framework for the design of sophisticated module systems; and advanced techniques in ML-style type inference.

Type Systems of Scripting Languages

This paper will take a look on the type systems of some scripting languages, focusing on JavaScript, Python and Ruby, and discusses about their dynamic and lightweight properties and also about the trade off between the advantages of using static type-checking and the preservation of their properties.

From type checking by recursive descent to type checking with an abstract machine

This paper demonstrates an application of techniques investigated by Danvy et al. to derive an abstract machine for typing from the traditional recursive descent approach, which exposes behaviour similar to Landin's SECD machine and gives a solid basis for further optimizations using abstract interpretation.

Design and Implementation of Gnarly , a Hybrid-Typed Programming Language

A type system, hybrid typing, and a programming language utilizing it, Gnarly, that negotiate the space between static and dynamic typing by allowing the programmer to select which typing paradigm he or she wishes to use at the level of individual terms rather than entire languages.

Type Systems and the Program Verification ∗

The famous slogan by Robin Milner said that ”well-typed programs do not go wrong”, but the question whether the type system prevents us from writing meaningful and errorfree programs is questioned.



Semantics of programming languages - structures and techniques

Semantics of Programming Languages exposes the basic motivations and philosophy underlying the applications of semantic techniques in computer science. It introduces the mathematical theory of

A Theory of Type Polymorphism in Programming

  • R. Milner
  • Computer Science
    J. Comput. Syst. Sci.
  • 1978

Typeful Programming

  • L. Cardelli
  • Computer Science
    Formal Description of Programming Concepts
  • 1989
It is shown how typeful programming is best supported by sophisticated type systems, and how these systems can help in clarifying programming issues and in adding power and regularity to languages.

On understanding types, data abstraction, and polymorphism

A λ-calculus-based model for type systems that allows us to explore the interaction among the concepts of type, data abstraction, and polymorphism in a simple setting, unencumbered by complexities of production programming languages is developed.

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.

The structure of typed programming languages

The text is unique in its tutorial presentation of higher-order lambda calculus and intuitionistic type theory, which reveals that a programming language is a logic in which its typing system defines the propositions of the logic and its well-typed programs constitute the proofs of the propositions.

Type Systems for Programming Languages

  • John C. Mitchell
  • Computer Science
    Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics
  • 1990

A paradigmatic object-oriented programming language: Design, static typing and semantics

  • Kim B. Bruce
  • Computer Science
    Journal of Functional Programming
  • 1994
The design of TOOPL is described, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance, and the semantics of the language is rather complex, involving fixed points at both the element and type level.

Dynamic typing in a statically-typed language

This paper is an exploration of the syntax, operational semantics, and denotational semantics of a simple language with the type Dynamic, and discusses an operational semantics for this language and obtains a soundness theorem.

Dependent types in practical programming

We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) language