A modular module system

A simple implementation of an SML-like module system is presented as a module parameterized by a base language and its type-checker. 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.

[1]  Donald Sannella,et al.  Extended ML: Past, Present, and Future , 1990, ADT.

[2]  Matthias Felleisen,et al.  Units: cool modules for HOT languages , 1998, PLDI.

[3]  Xavier Leroy,et al.  A syntactic theory of type generativity and sharing , 1996, Journal of Functional Programming.

[4]  J. Gregory Morrisett,et al.  Type-safe linking and modular assembly language , 1999, POPL '99.

[5]  Gilad Bracha,et al.  The programming language jigsaw: mixins, modularity and multiple inheritance , 1992 .

[6]  Luca Cardelli,et al.  Typeful Programming , 1989, Formal Description of Programming Concepts.

[7]  Dominic Duggan,et al.  Mixin modules , 1996, ICFP '96.

[8]  Simon L. Peyton Jones,et al.  The Implementation of Functional Programming Languages , 1987 .

[9]  Xavier Leroy,et al.  Le langage Caml , 1993 .

[10]  Mark Lillibridge,et al.  A type-theoretic approach to higher-order modules with sharing , 1994, POPL '94.

[11]  Jerome Vouillon.  Using modules as classes , 1997 .

[12]  Robin Milner,et al.  Definition of standard ML , 1990 .

[13]  Robert Harper,et al.  A type-theoretic interpretation of standard ML , 2000, Proof, Language, and Interaction.

[14]  John Launchbury,et al.  Unboxed values as first class citizens , 1991 .

[15]  Michel Mauny,et al.  A complete and realistic implementation of quotations for ML , 1994 .

[16]  John C. Mitchell,et al.  Higher-order modules and the phase distinction , 1989, POPL '90.

[17]  M. Lillibridge.  Translucent Sums: A Foundation for Higher-Order Module Systems , 1997 .

[18]  David B. MacQueen.  An implementation of standard ML modules , 1988, LISP and Functional Programming.

[19]  Luca Cardelli,et al.  Structural subtyping and the notion of power type , 1988, POPL '88.

[20]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[21]  Xavier Leroy,et al.  Applicative functors and fully transparent higher-order modules , 1995, POPL '95.

[22]  Luca Cardelli,et al.  Program fragments, linking, and modularization , 1997, POPL '97.

[23]  Simon L. Peyton Jones,et al.  Unboxed Values as First Class Citizens in a Non-Strict Functional Language , 1991, FPCA.

[24]  Martin Elsman.  Program modules, separate compilation, and intermodule optimisation , 1999, Technical report / University of Copenhagen / Datalogisk institut.

[25]  Xavier Leroy,et al.  Manifest types, modules, and separate compilation , 1994, POPL '94.

[26]  Robin Milner,et al.  Standard ML: Report ECS-LFCS-86-2 , 1986 .

[27]  Claudio V. Russo.  Types for Modules , 2004, Electronic Notes in Theoretical Computer Science.

[28]  Mads Tofte,et al.  A Semantics for Higher-Order Functors , 1994, ESOP.

[29]  Paul Le Guernic,et al.  An ML-Like Module System for the Synchronous Language SIGNAL , 1997, Euro-Par.

[30]  Thomas F. Gordon.  An Implementation in Standard ML , 1995 .

[31]  Mads Tofte,et al.  A Type-Theoretic Interpretation of Standard ML , 2000 .

[32]  Davide Ancona,et al.  A Primitive Calculus for Module Systems , 1999, PPDP.

[33]  Karl Crary,et al.  What is a recursive module? , 1999, PLDI '99.

[34]  Luca Cardelli,et al.  Basic Polymorphic Typechecking , 1987, Sci. Comput. Program..

[35]  Martin Wirsing,et al.  Algebraic Specification , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[36]  Judicaël Courant,et al.  A Module Calculus for Pure Type Systems , 1997, TLCA.

[37]  Xavier Leroy,et al.  Unboxed objects and polymorphic typing , 1992, POPL '92.

[38]  T Bell,et al.  An Implementation of Higher-Order FunctorsPierre Cr , 1994 .

[39]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[40]  Marvin V. Zelkowitz,et al.  Programming Languages: Design and Implementation , 1975 .

[41]  Michel Bidoit,et al.  TAPSOFT '97: Theory and Practice of Software Development , 1997, Lecture Notes in Computer Science.

[42]  Judicaël Courant,et al.  An Applicative Module Calculus , 1997, TAPSOFT.

[43]  Andrew K. Wright.  Simple imperative polymorphism , 1995, LISP Symb. Comput..

[44]  Davide Ancona,et al.  A theory of mixin modules: basic and derived operators , 1998, Mathematical Structures in Computer Science.

[45]  Donald Sannella,et al.  Programming Languages and Systems — ESOP '94 , 1994, Lecture Notes in Computer Science.

[46]  Pavel Curtis,et al.  A module system for scheme , 1990, LISP and Functional Programming.

[47]  Stephen J. Garland,et al.  Larch: Languages and Tools for Formal Specification , 1993, Texts and Monographs in Computer Science.

[48]  Robert Harper,et al.  TIL: a type-directed optimizing compiler for ML , 1996, PLDI '96.

[49]  Murray Hill.  An Implementation of Standard ML Modules , 1988 .

[50]  David B. MacQueen.  Modules for standard ML , 1984, LFP '84.

[51]  Donald Sannella,et al.  A Calculus for the Construction of Modular Prolog Programs , 1987, J. Log. Program..

[52]  John H. Reppy,et al.  The design of a class mechanism for Moby , 1999, PLDI '99.