Abstract types have existential type
ACM Transactions on Programming Languages and Systems (TOPLAS)
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Compiling polymorphism using intensional type analysis
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Operational reasoning for functions with local state
Higher order operational techniques in semantics
Relational interpretations of recursive types in an operational setting
Information and Computation
Parametricity and variants of Girard's J operator
Information Processing Letters
Modules, abstract types, and distributed versioning
POPL '01 Proceedings of the 28th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
An indexed model of recursive types for foundational proof-carrying code
ACM Transactions on Programming Languages and Systems (TOPLAS)
Representation independence and data abstraction
POPL '86 Proceedings of the 13th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Observable Properties of Higher Order Functions that Dynamically Create Local Names, or What's new?
MFCS '93 Proceedings of the 18th International Symposium on Mathematical Foundations of Computer Science
Generativity and dynamic opacity for abstract types
Proceedings of the 5th ACM SIGPLAN international conference on Principles and practice of declaritive programming
Logical relation for encryption
Journal of Computer Security - Special issue on CSFW14
Type-FUNCTIONAL PEARL safe cast
Journal of Functional Programming
Semantics of types for mutable state
Semantics of types for mutable state
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
Generalizing Parametricity Using Information-flow
LICS '05 Proceedings of the 20th Annual IEEE Symposium on Logic in Computer Science
A bisimulation for dynamic sealing
Theoretical Computer Science
A bisimulation for type abstraction and recursion
Journal of the ACM (JACM)
Acute: High-level programming language design for distributed computation
Journal of Functional Programming
Typed closure conversion preserves observational equivalence
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)
State-dependent representation independence
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compiling functional types to relational specifications for low level imperative code
Proceedings of the 4th international workshop on Types in language design and implementation
Parametric polymorphism through run-time sealing or, theorems for low, low prices!
ESOP'08/ETAPS'08 Proceedings of the Theory and practice of software, 17th European conference on Programming languages and systems
Generative type abstraction and type-level computation
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Step-Indexed syntactic logical relations for recursive and quantified types
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
The marriage of bisimulations and Kripke logical relations
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Mixin’ Up the ML Module System
ACM Transactions on Programming Languages and Systems (TOPLAS)
Logical relations for a logical framework
ACM Transactions on Computational Logic (TOCL)
Hi-index | 0.00 |
Type abstraction and intensional type analysis are features seemingly at odds-type abstraction is intended to guarantee parametricity and representation independence, while type analysis is inherently non-parametric. Recently, however, several researchers have proposed and implemented "dynamic type generation" as a way to reconcile these features. The idea is that, when one defines an abstract type, one should also be able to generate at runtime a fresh type name, which may be used as a dynamic representative of the abstract type for purposes of type analysis. The question remains: in a language with non-parametric polymorphism, does dynamic type generation provide us with the same kinds of abstraction guarantees that we get from parametric polymorphism? Our goal is to provide a rigorous answer to this question. We define a step-indexed Kripke logical relation for a language with both non-parametric polymorphism (in the form of type-safe cast) and dynamic type generation. Our logical relation enables us to establish parametricity and representation independence results, even in a non-parametric setting, by attaching arbitrary relational interpretations to dynamically generated type names. In addition, we explore how programs that are provably equivalent in a more traditional parametric logical relation may be "wrapped" systematically to produce terms that are related by our non-parametric relation, and vice versa. This leads us to develop a "polarized" variant of our logical relation, which enables us to distinguish formally between positive and negative notions of parametricity.