Abstract types have existential type

@article{Mitchell1988AbstractTH,
  title={Abstract types have existential type},
  author={John C. Mitchell and Gordon D. Plotkin},
  journal={ACM Trans. Program. Lang. Syst.},
  year={1988},
  volume={10},
  pages={470-502}
}
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… 
Polymorphic type inference and abstract data types
TLDR
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.
Pebble, a Kernel Language for Modules and Abstract Data Types
TLDR
Using a kernel language called Pebble based on the typed lambda calculus with bindings, declarations, dependent types, and types as compile time values, it is shown how to build modules, interfaces and implementations, abstract data types, generic types, recursivetypes, and unions.
Dynamic opacity for abstract types
TLDR
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
TLDR
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.
Putting type annotations to work
TLDR
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
In an open programming system dynamic type checking is needed to safely link statically typed components. Since type case destroys the parametricity of type abstraction, dynamically generated type
Existentially Quantified Procedures: A Mechanism for Abstracting Type in Dynamic Typing Constructs
TLDR
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
TLDR
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.
An Extension of ML with First-Class Abstract Types
TLDR
ML [MTH90] provides two distinct constructs for describing abstract data types: the (obsolete) abstype mechanism is used to declare an abstract data type with a single implementation, and the module system.
Soft Interfaces : Typing Scheme at the Module Level
Soft Interfaces is a module system for Scheme with typed interfaces. This makes it possible to declare the types of exported procedures in a language with union types, parametric polymorphism and
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 90 REFERENCES
Abstract types have existential types
TLDR
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
TLDR
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.
Representation independence and data abstraction
TLDR
This work studies the representation independence properties of a typed functional language with polymorphic functions and abstract data type declarations in which data type implementations may be passed as function parameters and returned as results.
Polymorphic Type Inference and Containment
TLDR
A general semantics of polymorphic type expressions over models of untyped lambda calculus and complete rules for inferring types for terms are presented.
Data types, parameters and type checking
TLDR
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"
  • J. Donahue
  • Mathematics, Computer Science
    SIAM J. Comput.
  • 1977
TLDR
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
TLDR
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.
The Semantics of Second-Order Lambda Calculus
TLDR
It is verified that some specific interpretations of the calculus proposed in the literature indeed yield models in the authors' sense, and two definitions of semantic models for this language are given and proved equivalent.
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, Mathematics
    22nd Annual Symposium on Foundations of Computer Science (sfcs 1981)
  • 1981
TLDR
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.
...
1
2
3
4
5
...