Abstract types have existential type

  title={Abstract types have existential type},
  author={John C. Mitchell and Gordon D. Plotkin},
  journal={ACM Trans. Program. Lang. Syst.},
Abstract data type declarations appear in typed programming languages like Ada, Alphard, CLU and ML. This form of declaration binds a list of identifiers to a type with associated operations, a composite “value” we call a data algebra. We use a second-order typed lambda calculus SOL to show how data algebras may be given types, passed as parameters, and returned as results of function calls. In the process, we discuss the semantics of abstract data type declarations and review a connection… 

Figures from this paper

Polymorphic type inference and abstract data types

This work shows how to add significant expressive power to statically typed functional languages with explicit type variables by incorporating first-class abstract types as an extension of algebraic data types and extends record types to allow abstract components.

Dynamic opacity for abstract types

This work presents a light-weight calculus for polymorphic languages with abstract types that retains most of the simplicity of standard existentials and relies on modified scoping rules and explicit coercions between the quantified variable and its witness type.

Quantified types in an imperative language

A formal abstract machine and type-safety proof that capture the essence of type variables at the C level is developed that avoids a subtle unsoundness issue resulting from the address-of operator.

Type classes with existential types

It is argued that the novel combination of type classes and existential types in a single language yields significant expressive power in the context of higher-order functional languages with static typing, parametric polymorphism, algebraic data types and Hindley–Milner type inference.

Putting type annotations to work

It is shown that type reconstruction in the Hindley/Milner system can be reduced to the decidable problem of first-order unification under a mixed prefix.

Polymorphic Lambda Calculus with Dynamic Types

This work will greatly simplify Rossberg’s calculus by developing a calculus, λ F, an extension of System F that provides constructs for type case and a binder for new type names and will prove the safety properties for both calculi.

Existentially Quantified Procedures: A Mechanism for Abstracting Type in Dynamic Typing Constructs

Existential quantification of procedures is introduced as a mechanism for languages with dynamic typing, where operations over values of the abstracted type may behave differently according to the actual specialisation.

A Logic for Abstract Data Types as Existential Types

It is shown that Plotkin and Abadi's logic for parametricity is not sufficient for reasoning about specifications of ADT's, and an extension of the logic is presented that does provide the proof principles forADT's that the authors want.

Abstract Data Types Can Have Inequations1

The type system of the proposed wide-spectrum Funiq language is shown to be a conservative extension of that of the original Fun and sound with respect to the complete PER semantics for types.



Abstract types have existential types

This work uses a second-order typed lambda calculus SOL to show how data algebras may be given types, passed as parameters, and returned as results of function calls.

A Kernel Language for Abstract Data Types and Modules

This work uses typed lambda calculus with bindings, declarations, and types as first-class values to build modules, interfaces and implementations, abstract data types, generic types, recursive types, and unions in a concise operational semantics given by inference rules.

Data types, parameters and type checking

A treatment of type-checking that makes it possible to do completely static checking with a general parameterization mechanism allowing parameterized types, types as parameters, and even a disciplined form of self-application.

On the Semantics of "Data Type"

This paper describes a new approach to defining the meaning of data types and gives its application to the definition of a typed lambda calculus extension and proves that the language is "strongly typed".

Semantic Models for Second-Order Lambda Calculus

This work aims to releive the model theorist of syntactic considerations for the second-order lambda calculus, a typed expression language with polymorphic functions and abstract data types.

Data types as values: polymorphism, type-checking, encapsulation

This paper describes a novel approach to the treatment of data types in programming languages, which allows a simple interpretation of "polymorphic" or "generic" procedures, makes a simple set of

Number theoretic functions computable by polymorphic programs

  • R. Statman
  • Computer Science
    22nd Annual Symposium on Foundations of Computer Science (sfcs 1981)
  • 1981
The polymorphic typed A-calculus is a model for such higher level programming languages as ALPHARD, MODEL, and RUSSELL and allows functions to be taken on as both arguments and values.

A Theory of Data Type Representation Independence

Two characterizations of representation independence are defined and shown to hold in TypeL given appropriate restrictions on the environments, and may be applied to high level language expressions if the semantics of these expressions can be defined by transformations into TypeL expressions.