Parameterized Modules for Classes and Extensible Functions

Lee, Keun-Woo; Chambers, Craig

doi:10.1007/11785477_21

Cited by 4 publications

(5 citation statements)

References 40 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Lee and Chambers developed F(EML) [6], which improves the module system of EML [8], an ML-like language that incorporates aspects of Dubious and System M. CF and F(EML) differ significantly in several ways: First, CF does not support parameterized modules. Second, although F(EML) allows exclusion relations between types, it treats inequality explicitly, tracking the freshness of classes and other declarations, which complicates its type system.…”

Section: Related Workmentioning

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

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%

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

“…While FGFV does not support features like modularity, nominal exclusion, and closed types in their work, they can be added in an obvious way. As the related work section of Allen et al [2011] discusses in detail, most earlier systems like Dubious [Millstein andChambers 1999, 2002;Millstein 2003], MultiJava [Clifton et al 2006], and F(EML) [Lee and Chambers 2006] supported overloading with symmetric multiple dynamic dispatch with multiple inheritance, but without support for polymorphic methods or types. While ML ≤ [Bourdoncle and Merz 1997] integrates polymorphism and symmetric multiple dynamic dispatch, it lacks multiple inheritance.…”

Section: Related Workmentioning

confidence: 99%

Polymorphic symmetric multiple dispatch with variance

Park

Hong

Steele

et al. 2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Many object-oriented languages provide method overloading, which allows multiple method declarations with the same name. For a given method invocation, in order to choose what method declaration to invoke, multiple dispatch considers the run-time types of the arguments. While multiple dispatch can support binary methods (such as mathematical operators) intuitively and consistently, it is difficult to guarantee that calls will be neither ambiguous nor undefined at run time, especially in the presence of expressive language features such as multiple inheritance and parametric polymorphism. Previous efforts have formalized languages that include such features by using overloading rules that guarantee a unique and type-sound resolution of each overloaded method call; in many cases, such rules resolve ambiguity by treating the arguments asymmetrically. Here we present the first formal specification of a strongly typed object-oriented language with symmetric multiple dispatch, multiple inheritance, and parametric polymorphism with variance. We define both a static (typechecking) semantics and a dynamic (dispatching) semantics and prove the type soundness of the language, thus demonstrating that our novel dynamic dispatch algorithm is consistent with the static semantics. Details of our dynamic dispatch algorithm address certain technical challenges that arise from structural asymmetries inherent in object-oriented languages (e.g., classes typically declare ancestors explicitly but not descendants). CCS Concepts: • Software and its engineering → General programming languages; • Social and professional topics → History of programming languages;

show abstract

“…Specifically, we define three rules: 9 the No Duplicates Rule ensures that no two declarations are equally specific; the Meet Rule ensures that the set of overloaded declarations form a meet semilattice under the specificity relation; and the Return Type Rule ensures type preservation for dynamic dispatch. We prove that any set of overloaded function declarations satisfying these three properties is safe, even if the class table is extended (Theorem 1).…”

Section: Overloading Rules and Resolutionmentioning

confidence: 99%

“…With Clifton and Leavens, they developed MultiJava [5], an extension of Java with Dubious' semantics for multimethods. Lee and Chambers presented F(EML) [9], a language with classes, symmetric multiple dispatch, and parameterized modules. In previous work [2], we built on the work of Millstein and Chambers to give modular rules for a core of the Fortress language [1], which supports multiple inheritance and does not require that types have expressible meets (i.e., the types that can be expressed in the language need not form a meet semilattice), but defines an exclusion 15 Suggested by an anonymous reviewer of a previous version of this paper.…”

Section: Overloading Across Modulesmentioning

confidence: 99%

Type checking modular multiple dispatch with parametric polymorphism and multiple inheritance

et al. 2011

View full text Add to dashboard Cite

In previous work, we presented rules for defining overloaded functions that ensure type safety under symmetric multiple dispatch in an object-oriented language with multiple inheritance, and we showed how to check these rules without requiring the entire type hierarchy to be known, thus supporting modularity and extensibility. In this work, we extend these rules to a language that supports parametric polymorphism on both classes and functions.In a multiple-inheritance language in which any type may be extended by types in other modules, some overloaded functions that might seem valid are correctly rejected by our rules. We explain how these functions can be permitted in a language that additionally supports an exclusion relation among types, allowing programmers to declare "nominal exclusions" and also implicitly imposing exclusion among different instances of each polymorphic type. We give rules for computing the exclusion relation, deriving many type exclusions from declared and implicit ones.We also show how to check our rules for ensuring the safety of overloaded functions. In particular, we reduce the problem of handling parametric polymorphism to one of determining subtyping relationships among universal and existential types. Our system has been implemented as part of the open-source Fortress compiler.

show abstract

Parameterized Modules for Classes and Extensible Functions

Cited by 4 publications

References 40 publications

Modular multiple dispatch with multiple inheritance

Modular multiple dispatch with multiple inheritance

Polymorphic symmetric multiple dispatch with variance

Type checking modular multiple dispatch with parametric polymorphism and multiple inheritance

Contact Info

Product

Resources

About