Subject-oriented programming: a critique of pure objects
OOPSLA '93 Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications
Covariance and contravariance: conflict without a cause
ACM Transactions on Programming Languages and Systems (TOPLAS)
A calculus for overloaded functions with subtyping
Information and Computation
Theory and Practice of Object Systems - Special issue: type systems
Parasitic methods: an implementation of multi-methods for Java
Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Type checking higher-order polymorphic multi-methods
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On the criteria to be used in decomposing systems into modules
Communications of the ACM
Featherweight Java: a minimal core calculus for Java and GJ
ACM Transactions on Programming Languages and Systems (TOPLAS)
Relaxed MultiJava: balancing extensibility and modular typechecking
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
MultiJava: Design rationale, compiler implementation, and applications
ACM Transactions on Programming Languages and Systems (TOPLAS)
Modular multiple dispatch with multiple inheritance
Proceedings of the 2007 ACM symposium on Applied computing
GPCE '07 Proceedings of the 6th international conference on Generative programming and component engineering
Efficient multimethods in a single dispatch language
ECOOP'05 Proceedings of the 19th European conference on Object-Oriented Programming
COQ mechanization of featherweight fortress with multiple dispatch and multiple inheritance
CPP'11 Proceedings of the First international conference on Certified Programs and Proofs
Hi-index | 0.00 |
In object systems, classes take the role of modules, and interfaces consist of methods. Because methods are encapsulated in objects, interfaces in object systems do not allow abstracting over where methods are implemented. This implies that any change to the implementation structure may cause a rippling effect. Sometimes this unduly restricts the scope of software evolution, in particular for methods with multiple parameters where there is no clear owner. We propose a simple scheme where symmetric methods may be defined in the classes of any of their parameters. This allows client code to be oblivious of what class contains a method implementation, and therefore immune against it changing. When combined with multiple dynamic dispatch, this scheme allows for modular extensibility (but not modular type-checking) where a method defined in one class is overridden by a method defined in a class that is not its subtype. In this paper, we illustrate the scheme by extending a core calculus of class-based languages with these symmetric encapsulated multi-methods, and prove the result sound.