Multiple dispatch in practice

@article{Muschevici2008MultipleDI,
  title={Multiple dispatch in practice},
  author={Radu Muschevici and Alex Potanin and Ewan D. Tempero and James Noble},
  journal={Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications},
  year={2008}
}
  • Radu Muschevici, A. Potanin, +1 author J. Noble
  • Published 19 October 2008
  • Computer Science
  • Proceedings of the 23rd ACM SIGPLAN conference on Object-oriented programming systems languages and applications
Multiple dispatch uses the run time types of more than one argument to a method call to determine which method body to run. While several languages over the last 20 years have provided multiple dispatch, most object-oriented languages still support only single dispatch forcing programmers to implement multiple dispatch manually when required. This paper presents an empirical study of the use of multiple dispatch in practice, considering six languages that support multiple dispatch, and also… 
Coq Mechanization of Featherweight Fortress with Multiple Dispatch and Multiple Inheritance
TLDR
A core calculus for the Fortress programming language is presented, which provides both multiple dispatch and multiple inheritance and is formally defined and mechanize the calculus and its type safety proof in Coq.
Design and evaluation of C++ open multi-methods
TLDR
This work presents the rationale, design, implementation, performance, programming guidelines, and experiences of working with a language feature, called open multi-methods, for C++, and describes a model implementation that is simpler to use, catches more user mistakes, and resolves more ambiguities through link-time analysis.
EVL: A framework for multi-methods in C++
TLDR
The EVL (Extended Virtual function Library) framework is presented which provides a set of classes in C++ aiming at solving the problem of multi-methods and provides both symmetric and asymmetric dispatch algorithms that can be refined by the programmer to include criteria other than class inheritance.
Array Operators Using Multiple Dispatch: A design methodology for array implementations in dynamic languages
TLDR
This work has come to believe that while multiple dispatch has not been especially popular in most kinds of programming, technical computing is its killer application, and has developed an approach that yields a novel trade-off between flexibility and compile-time analysis.
Coding Without Your Crystal Ball: Unanticipated Object-Oriented Reuse
TLDR
This work shows that languages can and should support a combination of structural and nominal subtyping, external dispatch, and a form of multiple inheritance, and proposes a novel form ofmultiple inheritance which does not allow diamonds, but recovers expressiveness through a generalized form of self-types.
JavaGI: The Interaction of Type Classes with Interfaces and Inheritance
TLDR
This article formalizes a core calculus for JavaGI and proves type soundness, decidability of typechecking, and determinacy of evaluation and presents the implementation of a JavaGI compiler and an accompanying run-time system.
Extending Dylan's type system for better type inference and error detection
TLDR
Dylan is extended with function types and parametric polymorphism with a unification-based type inference algorithm in the mainstream Dylan compiler and some previously undiscovered errors in the Dylan library were revealed.
Bytecodes meet combinators: invokedynamic on the JVM
TLDR
To generalize method calls on the JVM, the JSR 292 Expert Group has designed a new invokedynamic instruction that provides user-defined call site semantics, balancing the conciseness of bytecode with the dynamic flexibility of function pointers.
How developers use the dynamic features of programming languages: the case of smalltalk
TLDR
This paper performs an empirical study of a large Smalltalk codebase in order to assess how much these features are actually used in practice, whether some are used more than others, and in which kinds of projects.
Applying Types as Abstract Interpretation to a Language with Dynamic Dispatch
TLDR
To prove soundness of said type system, the abstract interpretation development of type systems for λC is extended to λK and the new type system is shown to be a sound abstraction in the sense of [Cou97].
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 105 REFERENCES
Multi-Dispatch in the Java Virtual Machine: Design and Implementation
TLDR
The general-purpose technique provides smaller dispatch latency than programmer-written double-dispatch code with equivalent functionality and isolates the performance penalty and semantic changes of multimethod dispatch to the program sections which use it.
Multiple dispatch as dispatch on Tuples
TLDR
A new, simple, and orthogonal way to add multimethods to single-dispatch object-oriented languages, without affecting existing code is described.
PolyD: a flexible dispatching framework
TLDR
This paper presents a tool, PolyD, that allows the programmer to design custom dispatching strategies and to parametrize many aspects of the dispatching process, and exhibits excellent performance and compares well against existing tools.
Open multi-methods for c++
TLDR
This work presents the rationale, design, implementation, and performance of a language feature, called open multi-methods, for C++, and describes a model implementation that is simpler to use, catches more user mistakes, and resolves more ambiguities through link-time analysis.
Multiple dispatch in practice
Multiple dispatch uses the run time types of more than one argument to a method call to determine which method body to run. While several languages over the last 20 years have provided multiple dis...
Efficient multiple and predicated dispatching
TLDR
An algorithm for constructing efficient dispatch functions that combines novel algorithms for efficient single dispatching, multiple dispatches, and predicate dispatching is developed, showing improvements of up to 30% over already heavily optimized baseline versions.
Object-Oriented Multi-Methods in Cecil
TLDR
This work proposes an alternative view of multiple dispatching that is intended to promote a data-abstraction-oriented programming style, and explores this object-oriented view of multi-methods in the context of a new programming language named Cecil.
MultiJava: modular open classes and symmetric multiple dispatch for Java
TLDR
MultiJava is presented, a backward-compatible extension to Java supporting open classes and symmetric multiple dispatch, and adapt previous theoretical work to allow compilation units to be statically typechecked modularly and safely, ruling out any link-time or run-time type errors.
MultiJava: Design rationale, compiler implementation, and applications
TLDR
The design of MultiJava is illustrated and motivates and its modular static typechecking and modular compilation strategies are described, allowing users to express desired programming idioms in a way that is declarative and supports static type checking, in contrast to the tedious and type-unsafe workarounds required in Java.
Prototypes with Multiple Dispatch: An Expressive and Dynamic Object Model
TLDR
This paper introduces a novel object model, prototypes with multiple dispatch (PMD), which seamlessly unifies these two approaches to object-oriented programming, and gives formal semantics for PMD.
...
1
2
3
4
5
...