Results 1  10
of
10
A Calculus of Module Systems
, 2001
"... We present CMS, a simple and powerful calculus of modules supporting mutual recursion and higher order features, which can be instantiated over an arbitrary core calculus satisfying standard assumptions. The calculus allows expression of a large variety of existing mechanisms for combining software ..."
Abstract

Cited by 109 (28 self)
 Add to MetaCart
We present CMS, a simple and powerful calculus of modules supporting mutual recursion and higher order features, which can be instantiated over an arbitrary core calculus satisfying standard assumptions. The calculus allows expression of a large variety of existing mechanisms for combining software components, including parameterized modules similar to ML functors, extension with overriding as in objectoriented programming, mixin modules and extralinguistic mechanisms like those provided by a linker. Hence CMS can be used as a paradigmatic calculus for modular languages, in the same spirit the lambda calculus is used for functional programming. We rst present an untyped version of the calculus and then a type system; we prove conuence, progress, and subject reduction properties. Then, we dene a derived calculus of mixin modules directly in terms of CMS and show how to encode other primitive calculi into CMS (the lambda calculus and the AbadiCardelli object calculus). Finally, we consider the problem of introducing a subtype relation for module types.
What is a Recursive Module?
 In SIGPLAN Conference on Programming Language Design and Implementation
, 1999
"... A hierarchical module system is an effective tool for structuring large programs. Strictly hierarchical module systems impose an acyclic ordering on import dependencies among program units. This can impede modular programming by forcing mutuallydependent components to be consolidated into a single ..."
Abstract

Cited by 88 (5 self)
 Add to MetaCart
A hierarchical module system is an effective tool for structuring large programs. Strictly hierarchical module systems impose an acyclic ordering on import dependencies among program units. This can impede modular programming by forcing mutuallydependent components to be consolidated into a single module. Recently there have been several proposals for module systems that admit cyclic dependencies, but it is not clear how these proposals relate to one another, nor how one might integrate them into an expressive module system such as that of ML. To address this question we provide a typetheoretic analysis of the notion of a recursive module in the context of a "phasedistinction" formalism for higherorder module systems. We extend this calculus with a recursive module mechanism and a new form of signature, called a recursively dependent signature, to support the defmition of recursive modules. These extensions are justified by an interpretation in terms of more primitive language constructs. This interpretation may also serve as a guide for implementation.
A Theory of Mixin Modules: Basic and Derived Operators
 Mathematical Structures in Computer Science
, 1996
"... Mixins are modules in which some components are deferred , i.e. their definition has to be provided by another module. Moreover, differently from parameterized modules (like ML functors), mixin modules can be mutually dependent and their composition supports redefinition of components (overriding). ..."
Abstract

Cited by 39 (13 self)
 Add to MetaCart
Mixins are modules in which some components are deferred , i.e. their definition has to be provided by another module. Moreover, differently from parameterized modules (like ML functors), mixin modules can be mutually dependent and their composition supports redefinition of components (overriding). In this paper, we present a formal model of mixins and their basic composition operators. These operators can be viewed as a kernel language with clean semantics in which to express more complex operators of existing modular languages, including variants of inheritance in object oriented programming. Our formal model is given in an "institution independent" way, i.e. is parameterized by the semantic framework modeling the underlying core language. Introduction In object oriented languages, the definition of an heir class H from a parent class P takes usually the form H = extend P by M , where M denotes a collection of definitions of components (typically methods) which are either new, or re...
Equational Reasoning for Linking with FirstClass Primitive Modules
 In European Symposium on Programming
, 2000
"... . Modules and linking are usually formalized by encodings which use the calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we introduce the mcalculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of mo ..."
Abstract

Cited by 27 (5 self)
 Add to MetaCart
. Modules and linking are usually formalized by encodings which use the calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we introduce the mcalculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of module components. The mcalculus supports smooth encodings of software structuring tools such as functions ( calculus), records, objects (&calculus), and mutually recursive definitions. The mcalculus can also express widely varying kinds of module systems as used in languages like C, Haskell, and ML. We prove the mcalculus is confluent, thereby showing that equational reasoning via the mcalculus is sensible and well behaved. 1 Introduction A long version of this paper [43] which contains full proofs, more details and explanations, and comparisons with more calculi (including the calculus of Ancona and Zucca [4]), is available at http://www.cee.hw.ac.uk/~jbw/papers/. 1.1 Support f...
An Algebraic Approach to Mixins and Modularity
 ALP '96  5th Intl. Conf. on Algebraic and Logic Programming, number 1139 in Lecture Notes in Computer Science
, 1996
"... . We present an algebraic formalization of the notion of mixin module, i.e. a module where the definition of some components is deferred . Moreover, we define a set of basic operators for composing mixin modules, intended to be a kernel language with clean semantics in which to express more complex ..."
Abstract

Cited by 22 (4 self)
 Add to MetaCart
. We present an algebraic formalization of the notion of mixin module, i.e. a module where the definition of some components is deferred . Moreover, we define a set of basic operators for composing mixin modules, intended to be a kernel language with clean semantics in which to express more complex operators of existing modular languages, including variants of inheritance in object oriented programming. The semantics of the operators is given in an "institution independent" way, i.e. is parameterized on the semantic framework modeling the underlying core language. Introduction One of the major contributions of object oriented programming has been the discover of inheritance as primary mean for incremental software development. In object oriented languages, an heir class can extend the definition of the parent class adding new methods, as well as redefining old methods, overriding their preceding definitions (sometimes the precedence is given to the parent, see [7]). Note that, since ...
Confluent Equational Reasoning for Linking with FirstClass Primitive Modules
 In ESOP 2000  European Symposium on Programming 2000, number 1782 in Lecture Notes in Computer Science
, 1999
"... Modules and linking are usually formalized by encodings which use the lambda calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we present the mcalculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of modu ..."
Abstract

Cited by 17 (3 self)
 Add to MetaCart
Modules and linking are usually formalized by encodings which use the lambda calculus, records (possibly dependent), and possibly some construct for recursion. In contrast, we present the mcalculus, a calculus where the primitive constructs are modules, linking, and the selection and hiding of module components. In addition to supporting equational reasoning about modules and linking, the mcalculus allows smooth encodings of software structuring tools such as the lambda calculus, mutually recursive definitions, records (including operations like extension and concatenation), and objects. The mcalculus is extremely well behaved  we show not only that the mcalculus is confluent but also that it satisfies the strong finite developments property.
A Core Calculus of HigherOrder Mixins and Classes
 In Proc. of TYPES ’03, LNCS
"... Lorenzo Bettini Viviana Bono Silvia Likavec Dipartimento di Sistemi ed Informatica, Universit a di Firenze, bettini@dsi.unifi.it Dipartimento di Informatica, Universit a di Torino,{bono,likavec}@di.unito.it ABSTRACT We present an objectoriented calculus based on higherorder mixin con ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
Lorenzo Bettini Viviana Bono Silvia Likavec Dipartimento di Sistemi ed Informatica, Universit a di Firenze, bettini@dsi.unifi.it Dipartimento di Informatica, Universit a di Torino,{bono,likavec}@di.unito.it ABSTRACT We present an objectoriented calculus based on higherorder mixin construction via mixin composition, where some software engineering requirements are modelled in a formal setting, allowing to prove the absence of messagenotunderstood runtime errors.
An Algebraic Framework for Separate TypeChecking
 WADT'98 (13th Workshop on Algebraic Development Techniques
, 1999
"... . We address the problem of defining an algebraic framework for modularization supporting separate typechecking. In order to do that we introduce the notions of abstract type system and logic of constraints and we present a canonical construction of a model part, on top of a logic of constraints. T ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
. We address the problem of defining an algebraic framework for modularization supporting separate typechecking. In order to do that we introduce the notions of abstract type system and logic of constraints and we present a canonical construction of a model part, on top of a logic of constraints. This canonical construction works under standard assumptions on the underlying type system. We show that the framework is suitable for defining the static and dynamic semantics of module languages, by giving a concrete example of construction on top of the type system of a simple typed module language. As a result, the subtyping relation between module interfaces is captured in a natural way by the notion of signature morphism. Introduction Modularization has been considered since the early 70s an essential principle for managing the complex task of software development [29]. Nowadays there exist many modular programming languages offering rather advanced features for modularization. Neverth...
Featherweight javamip: a calculus for a modular object initialization protocol. Manuscript, available at http://www.di.unito.it/∼bono/papers/FWJavaMIP.pdf
, 2006
"... Abstract. Objectoriented classbased languages provide mechanisms for the initialization of newlycreated objects. These mechanisms specify how an object is initialized and what information is needed to do so. The initialization protocol is usually implemented as a list of constructors. It is often ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. Objectoriented classbased languages provide mechanisms for the initialization of newlycreated objects. These mechanisms specify how an object is initialized and what information is needed to do so. The initialization protocol is usually implemented as a list of constructors. It is often the case that the initialization protocol concerns some orthogonal properties of objects. Unfortunately, if those properties have more than one option of initialization, the total number of constructors becomes exponential in the number of properties. Moreover, extending an existing class even with one only feature concerning an object property often requires defining one constructor for each of the parent constructors. As a further consequence of that fact, the subclass constructors must reference explicitly its superclass constructors. In this paper, we propose an alternative approach to the classical object initialization protocol. In our approach, instead of defining a list of constructors, we split blocks of definitions into smaller and composable pieces, in order to obtain reduction in the size of the code, better reusability, more expressiveness, and easier maintenance. To describe this idea, we present the calculus Featherweight JavaMIP, in the style of IgarashiPierceWadler’s Featherweight Java. 1