Manifest types, modules, and separate compilation

@inproceedings{Leroy1994ManifestTM,
  title={Manifest types, modules, and separate compilation},
  author={Xavier Leroy},
  booktitle={POPL '94},
  year={1994}
}
  • X. Leroy
  • Published in POPL '94 1 February 1994
  • Computer Science
This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose definitions are part of the module specification), while retaining most of the expressive power of the SML module system. The resulting module system provides much better support for separate compilation. 

Figures from this paper

A modular module system
  • X. Leroy
  • Computer Science
    J. Funct. Program.
  • 2000
TLDR
This implementation is useful both as a detailed tutorial on the Harper–Lillibridge–Leroy module system and its implementation, and as a constructive demonstration of the applicability of that module system to a wide range of programming languages.
Reduction Semantics, Side Effects, Types
TLDR
A language of mixin modules that supports call-by-value evaluation, and formalize a reduction semantics and a sound type system for this language.
An Applicative Module Calculus
TLDR
The SML-like module systems are small typed languages of their own, but the subject-reduction property and the preservation of type abstraction seem to be incompatible.
Program fragments, linking, and modularization
TLDR
This paper proposes a framework where each module is separately compiled to a self-contained entity called a linkset; it is shown that separately compiled, compatible modules can be safely linked together.
Static interpretation of modules
This paper presents a technique for compiling Standard ML Modules into typed intermediate language fragments, which may be compiled separately and linked using traditional linking technology to form
Modules, abstract types, and distributed versioning
TLDR
The system makes use of a second-class module system with singleton kinds, giving a novel operational semantics for separate compilation/linking and execution of programs that interact along typed channels.
Polymorphism and subtyping in interface
TLDR
This document describes RAPIDE interfaces, their expressiveness and their use as a typing construct, along with associated programming tools.
Polymorphism and Subtyping in Interfaces
TLDR
This document describes RAPIDE interfaces, their expressiveness and their use as a typing construct, along with associated programming tools.
Syntactic abstraction in component interfaces
TLDR
This combination places macro definitions inside component signatures, thereby permitting macro expansion at compile time, while still allowing independent compilation and linking for the run-time part of components.
Path dependent types with path-equality
TLDR
This paper proposes to extend the Scala type system with path-equality, and formalize it as a DOT variant, π DOT, which supports records with type members and elds, and shows that ρ DOT has the normalization property and proves its type soundness.
...
...

References

SHOWING 1-10 OF 34 REFERENCES
A Type Discipline for Program Modules
TLDR
A static semantics for a fragment of the ML modules system is presented in the style of Plotkin's operational semantics, with interesting parallels with the type assignment rules for ML given by Damas and Milner.
Higher-order modules and the phase distinction
TLDR
This paper introduces a refinement of XML with a clear compile-time/run-time phase distinction, and a direct compile- time type checking algorithm, and enforces the phase distinction using a nonstandard equational theory for module and signature expressions.
Modules for standard ML
TLDR
The module facility described here has been proposed as part of the revised language, now called Standard ML, to facilitate the structuring of large ML programs and to employ new ideas in the semantics of data types to extend the power of ML's polymorphic type system.
Principal signatures for higher-order program modules
TLDR
This work presents a type discipline for a skeletal higher-order module language which has principal signatures and shares and multiple views of structures are handled in a manner which is compatible with the semantics of the first-order ML modules.
Extending record typing to type parametric modules with sharing
TLDR
This work obtains a type system for modules based only on well known unification problems, modulo some equational theories the authors define, that has the elegance of polymorphic type disciplines based on unification.
Formal description of programming concepts
TLDR
Contents: P.D. Mosses: A Practical Introduction to Denotational Semantics, E.R. Olderog: Introduction to Program Verification.
Abstract types have existential type
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.
Structural subtyping and the notion of power type
TLDR
The mixing of value and type levels becomes a considerable obstacle when considering compiled languages, or languages extended with imperative features, which must make a clear distinction between compile-time and run-time phases.
A type-theoretic approach to higher-order modules with sharing
TLDR
These problems are addressed from a type-theoretic viewpoint by considering a calculus based on Girard's system Fω that provides complete control over the propagation of compile-time information between program units and is sufficient to encode in a straightforward way most users of type sharing specifications in Standard ML.
Smartest recompilation
TLDR
An algorithm is presented which can automatically infer the “minimum” import interface for any module in languages based on the Damas-Milner type discipline, which is just enough to make the module type-check and compile.
...
...