PolyAML: a polymorphic aspect-oriented functional programming language
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Proceedings of the 2006 ACM SIGPLAN workshop on Generic programming
Free Theorems and Runtime Type Representations
Electronic Notes in Theoretical Computer Science (ENTCS)
AspectML: A polymorphic aspect-oriented functional programming language
ACM Transactions on Programming Languages and Systems (TOPLAS)
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
What does aspect-oriented programming mean for functional programmers?
Proceedings of the 2009 ACM SIGPLAN workshop on Generic programming
Parametricity, type equality, and higher-order polymorphism
Journal of Functional Programming
Journal of Functional Programming - Dedicated to ICFP 2009
Behavioral polymorphism and parametricity in session-based communication
ESOP'13 Proceedings of the 22nd European conference on Programming Languages and Systems
Hi-index | 0.00 |
Run-time type analysis allows programmers to easily and concisely define operations based upon type structure, such as serialization, iterators, and structural equality. However, when types can be inspected at run time, nothing is secret. A module writer cannot use type abstraction to hide implementation details from clients: clients can determine the structure of these supposedly "abstract" data types. Furthermore, access control mechanisms do not help isolate the implementation of abstract datatypes from their clients. Buggy or malicious authorized modules may leak type information to unauthorized clients, so module implementors cannot reliably tell which parts of a program rely on their type definitions. Currently, module implementors rely on parametric polymorphism to provide integrity and confidentiality guarantees about their abstract datatypes. However, standard parametricity does not hold for languages with run-time type analysis; this paper shows how to generalize parametricity so that it does. The key is to augment the type system with annotations about information-flow. Implementors can then easily see which parts of a program depend on the chosen implementation by tracking the flow of dynamic type information.