ACM Transactions on Programming Languages and Systems (TOPLAS)
The type and effect discipline
Information and Computation
Applicative functors and fully transparent higher-order modules
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Using parameterized signatures to express modular structure
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Foundations of programming languages
Foundations of programming languages
Units: cool modules for HOT languages
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Purely functional data structures
Purely functional data structures
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Integrating functional and imperative programming
LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
A type-theoretic interpretation of standard ML
Proof, language, and interaction
Typed memory management via static capabilities
ACM Transactions on Programming Languages and Systems (TOPLAS)
Recursive structures for standard ML
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
The Definition of Standard ML
Type-Safe linking with recursive DLLs and shared libraries
ACM Transactions on Programming Languages and Systems (TOPLAS)
A type system for higher-order modules
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Typed compilation of recursive datatypes
Proceedings of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation
A Primitive Calculus for Module Systems
PPDP '99 Proceedings of the International Conference PPDP'99 on Principles and Practice of Declarative Programming
Generativity and dynamic opacity for abstract types
Proceedings of the 5th ACM SIGPLAN international conference on Principles and practice of declaritive programming
Listlessness is better than laziness: an algorithm that transforms applicative programs to eliminate intermediate lists
A type system for well-founded recursion
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Understanding and evolving the ml module system
Understanding and evolving the ml module system
Small bisimulations for reasoning about higher-order imperative programs
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Extensional equivalence and singleton types
ACM Transactions on Computational Logic (TOCL)
Principal type schemes for modular programs
ESOP'07 Proceedings of the 16th European conference on Programming
Relational reasoning in a nominal semantics for storage
TLCA'05 Proceedings of the 7th international conference on Typed Lambda Calculi and Applications
L3: a linear language with locations
TLCA'05 Proceedings of the 7th international conference on Typed Lambda Calculi and Applications
Relational reasoning for recursive types and references
APLAS'06 Proceedings of the 4th Asian conference on Programming Languages and Systems
Mixin' up the ML module system
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Dynamic Translucency with Abstraction Kinds and Higher-Order Coercions
Electronic Notes in Theoretical Computer Science (ENTCS)
Modeling abstract types in modules with open existential types
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 5th ACM SIGPLAN workshop on Types in language design and implementation
A syntactic type system for recursive modules
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Mixin’ Up the ML Module System
ACM Transactions on Programming Languages and Systems (TOPLAS)
Backpack: retrofitting Haskell with interfaces
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Hi-index | 0.00 |
Existential types provide a simple and elegant foundation for understanding generative abstract data types of the kind supported by the Standard ML module system. However, in attempting to extend ML with support for recursive modules, we have found that the traditional existential account of type generativity does not work well in the presence of mutually recursive module definitions. The key problem is that, in recursive modules, one may wish to define an abstract type in a context where a name for the type already exists, but the existential type mechanism does not allow one to do so. We propose a novel account of recursive type generativity that resolves this problem. The basic idea is to separate the act of generating a name for an abstract type from the act of defining its underlying representation. To define several abstract types recursively, one may first ‘forward-declare’ them by generating their names, and then supply each one's identity secretly within its own defining expression. Intuitively, this can be viewed as a kind of backpatching semantics for recursion at the level of types. Care must be taken to ensure that a type name is not defined more than once, and that cycles do not arise among ‘transparent’ type definitions. In contrast to the usual continuation-passing interpretation of existential types in terms of universal types, our account of type generativity suggests a destination-passing interpretation. Briefly, instead of viewing a value of existential type as something that creates a new abstract type every time it is unpacked, we view it as a function that takes as input a pre-existing undefined abstract type and defines it. By leaving the creation of the abstract type name up to the client of the existential, our approach makes it significantly easier to link abstract data types together recursively.