CLU reference manual
Proc. of the thirteenth spring school of the LITP on Combinators and functional programming languages
How to make ad-hoc polymorphism less ad hoc
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Dynamic typing in a statically typed language
ACM Transactions on Programming Languages and Systems (TOPLAS)
Analytical and structural polymorphism expressed using patterns over types
Analytical and structural polymorphism expressed using patterns over types
Design patterns: elements of reusable object-oriented software
Design patterns: elements of reusable object-oriented software
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compiling polymorphism using intensional type analysis
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
ESOP '94 Selected papers of ESOP '94, the 5th European symposium on Programming
PolyP—a polytypic programming language extension
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Making the future safe for the past: adding genericity to the Java programming language
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Compatible genericity with run-time types for the Java programming language
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Parametric polymorphism for Java: a reflective solution
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Featherweight Java: a minimal core calculus for Java and GJ
ACM Transactions on Programming Languages and Systems (TOPLAS)
The Definition of Standard ML
The Java Language Specification
The Java Language Specification
Guarded recursive datatype constructors
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The case for run-time types in generic Java
PPPJ '02/IRE '02 Proceedings of the inaugural conference on the Principles and Practice of programming, 2002 and Proceedings of the second workshop on Intermediate representation engineering for virtual machines, 2002
Proceedings of the 5th ACM Conference on Functional Programming Languages and Computer Architecture
The Essence of the Visitor Pattern
COMPSAC '98 Proceedings of the 22nd International Computer Software and Applications Conference
Efficient Implementation of Run-time Generic Types for Java
Proceedings of the IFIP TC2/WG2.1 Working Conference on Generic Programming
Safe and Flexible Dynamic Linking of Native Code
TIC '00 Selected papers from the Third International Workshop on Types in Compilation
Higher-Order Intensional Type Analysis
ESOP '02 Proceedings of the 11th European Symposium on Programming Languages and Systems
Intensional polymorphism in type-erasure semantics
Journal of Functional Programming
Journal of Functional Programming
Simula Begin
Prototyping an online wetland ecosystem services model using open model sharing standards
Environmental Modelling & Software
Distributed class code and data propagation with java
KES'06 Proceedings of the 10th international conference on Knowledge-Based Intelligent Information and Engineering Systems - Volume Part II
Hi-index | 0.00 |
Type-directed programming is an important and widely used paradigm in the design of software. With this form of programming, an application may analyze type information to determine its behavior. By analyzing the structure of data, many operations, such as serialization, cloning, adaptors and iterators may be defined once, for all types of data. That way, as the program evolves, these operations need not be updated-they will automatically adapt to new data forms. Otherwise, each of these operations must be individually redefined for each type of data, forcing programmers to revisit the same program logic many times during a program's lifetime. The Java language supports type directed programming with the instanceof operator and the Java Reflection API. These mechanisms allow Java programs to depend on the name and structure of the run-time classes of objects. However, the Java mechanisms for type-directed programming are difficult to use. They also do not integrate well with generics, an important new feature of the Java language. In this paper, we describe the design of several expressive new mechanisms for type-directed programming in Java, and show that these mechanisms are sound when included in a language similar to Featherweight Java. Basically, these new mechanisms pattern-match the name and structure of the type parameters of generic code, instead of the run-time classes of objects. Therefore, they naturally integrate with generics and provide strong guarantees about program correctness. As these mechanisms are based on pattern matching, they naturally and succinctly express many operations that depend on type information. Finally, they provide programmers with some degree of protection for their abstractions. Whereas instanceof and reflection can determine the exact run-time type of an object, our mechanisms allow any supertype to be supplied for analysis, hiding its precise structure.