Modular Statically Typed Multimethods

Millstein, Todd; Chambers, Craig

doi:10.1007/3-540-48743-3_13

Cited by 27 publications

(10 citation statements)

References 33 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Our system builds on the work of Millstein and Chambers [9,7], who introduce the Dubious language to illustrate and explore the challenges of modularly ensuring that no undefined nor ambiguous calls occur at run time, resulting in the definition of System M, a statically checkable set of restrictions on modules that guarantees this property. 2 Dubious supports overloaded functions with symmetric multiple dispatch (which they call multimethods) and multiple inheritance.…”

Section: Related Workmentioning

confidence: 99%

“…Millstein and Chambers studied this problem and developed System M, a set of such restrictions that can be checked modularly. But System M prevents multiple implementation inheritance across module boundaries [9]. In this paper, we describe a new set of overloading restrictions that can be statically and modularly checked without forbidding multiple inheritance.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Modular multiple dispatch with multiple inheritance

Allen

Hallett

Luchangco

et al. 2007

Proceedings of the 2007 ACM Symposium on Applied Computing

View full text Add to dashboard Cite

Overloaded functions and methods with multiple dispatch are useful for extending the functionality of existing classes in an objectoriented language. However, such functions introduce the possibility of ambiguous calls that cannot be resolved at run time, and modular static checking that such ambiguity does not exist has proved elusive in the presence of multiple implementation inheritance. We present a core language for defining overloaded functions and methods that supports multiple dispatch and multiple inheritance, together with a set of restrictions on these definitions that can be statically and modularly checked. We have proved that these restrictions guarantee that no undefined nor ambiguous calls occur at run time, while still permitting various kinds of overloading.

show abstract

Section: Related Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Modular multiple dispatch with multiple inheritance

Allen

Hallett

Luchangco

et al. 2007

Proceedings of the 2007 ACM Symposium on Applied Computing

View full text Add to dashboard Cite

show abstract

“…Millstein and Chambers show in [28] that open-methods cannot be modularly type checked if the language (like C++) supports multiple implementation inheritance. Therefore, we split our call resolution mechanism into three distinct stages:…”

Section: Definition 1 An Open-methods Is Considered An Overrider (Or)mentioning

confidence: 99%

“…When declared within classes, such functions are often referred to as "multi-methods". When declared independently of the type on which they dispatch, such functions are often referred to as open class extensions, accessory functions [39], arbitrary multi-methods [28], or "open-methods". Languages supporting multiple dispatch include CLOS [32], MultiJava [12,27], Dylan [30], and Cecil [10]).…”

Section: Introductionmentioning

confidence: 99%

Open multi-methods for c++

Pirkelbauer

Solodkyy

Stroustrup

2007

Proceedings of the 6th International Conference on Generative Programming and Component Engineering

View full text Add to dashboard Cite

Multiple dispatch -the selection of a function to be invoked based on the dynamic type of two or more arguments -is a solution to several classical problems in object-oriented programming. Open multi-methods generalize multiple dispatch towards open-class extensions, which improve separation of concerns and provisions for retroactive design. We present the rationale, design, implementation, and performance of a language feature, called open multimethods, for C++. Our open multi-methods support both repeated and virtual inheritance. Our call resolution rules generalize both virtual function dispatch and overload resolution semantics. After using all information from argument types, these rules can resolve further ambiguities by using covariant return types. Great care was taken to integrate open multi-methods with existing C++ language features and rules. We describe a model implementation and compare its performance and space requirements to existing open multi-method extensions and workaround techniques for C++. Compared to these techniques, our approach is simpler to use, catches more user mistakes, and resolves more ambiguities through link-time analysis, runs significantly faster, and requires less memory. In particular, the runtime cost of calling an open multimethod is constant and less than the cost of a double dispatch (two virtual function calls). Finally, we provide a sketch of a design for open multi-methods in the presence of dynamic loading and linking of libraries.

show abstract

“…Secondly, it may be used as a further filter of visibility of methods. Symmetric multi-methods introduce the possibility of ambiguity in dispatch [10]. Guarding against such ambiguity is done at the service level and checked at service compilation time.…”

Section: Services and Service Compositionmentioning

confidence: 99%

Promoting evolution by abstracting over implementation structure

Lievens

Walsh

Dahlem

et al. 2009

2009 31st International Conference on Software Engineering - Companion Volume

View full text Add to dashboard Cite

In service-oriented architectures, services present to their clients a single interface encompassing all the available functionality. In doing so, they offer an abstraction over the implementation structure of the service, insulating clients from changes to that structure. Abstraction over implementation structure yields benefits in terms of software evolution, and hence can be viewed as a general technique for good software engineering. As such, it should become part of mainstream software development, used outside of the loosely-coupled networks of business applications which services-oriented software addresses. In this paper we give an overview of the design of Continuum, a language-based approach that extends the conventional object model with facilities to abstract over implementation structure and aims to support the construction of malleable software.

show abstract

Modular Statically Typed Multimethods

Cited by 27 publications

References 33 publications

Modular multiple dispatch with multiple inheritance

Modular multiple dispatch with multiple inheritance

Open multi-methods for c++

Promoting evolution by abstracting over implementation structure

Contact Info

Product

Resources

About