Mark P. Jones. Using parameterized signatures to express modular structure. In POPL '96.  Home/Search   Document Details and Download   Summary   Related Articles   Check

....deserve, will be discussed in detail, reworked and extended to the full language in Chapter 5. For a more radical but conceptually simpler approach to modules, based on interpreting some, but not all, of the features of Standard ML Modules directly in an extension of the Core language, see Jones [26]. The companion paper by Nicklish and Peyton Jones [47] o#ers an informal comparison of the two approaches. One characteristic feature of Standard ML Modules is the ability to define structures containing both type and term components. Although the second order existential types underlying SOL ....

Mark P. Jones. Using parameterized signatures to express modular structure. In Proc. 23rd Symp. Principles of Prog. Lang. ACM Press, 1996.

.... Type systems for records have become a playing field for type theorists [HP91, Car84, CM89, EST95, R em95a, Jon92, Oho95, Wan88, Wan89, R em95b, R em89] One of the main motivations for record systems is that they can be used to encode object calculi [Wan89, R em95a] or module systems [Apo93, Jon96] Also, they are useful for data type declarations and in database programming [OB88] But there are a couple of challenging problems to Supported by Yale University Fellowship overcome. The type system should support polymorphic records and additional operations like extensions of records. ....

Mark P. Jones. Using parameterized signatures to express modular structure. In Proc. 23rd ACM Symposium on Principles of Programming Languages, pages 68--78, January 1996.

....record selection expression is well formed, that is, that l i i = # t or k i i = # t for some t. We have assumed here that both kinds of type declarations only mention variables that appear in the argument list #. As has been described by Laufer, Jones, and others [Lau92, Jon96, Jon97] lifting this restriction for a constructor type naturally leads to a system with support for local existential quantification, while the corresponding generalization for selector types is best interpreted as local universal quantification. The specifics of such a system is beyond the ....

M.P. Jones. Using Parameterized Signatures to Express Modular Structure. In ACM Principles of Programming Languages, St Petersburg, FL, January 1996. ACM Press.

....for this reason Russo does not propose his representation as an alternative to SML source syntax. He investigates instead mappings of SML source into his framework, so that his representation needs to be used only internally. This choice is not the only possible one; for instance Mark Jones [Jon96] proposes similar techniques as a way to express modular structure in the source language itself. But in our opinion the lifting techniques are notationally too heavy in programs where objects represented as modules are ubiquitous. 3 Principles of Nested Types Is there a middle road between the ....

Mark P. Jones. Using parameterized signatures to express modular structure. In Conference Record of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL'96), St. Petersburg, Florida, January 21--24, 1996. ACM Press.

....of StringSet1.set and StringSet2.set is highly dependent upon the compare functions, letting them be equal can give strange results but no type error can occur. Nonetheless some safety brought by abstract data types is lost. The same problem arises in Jones s proposal for modular programming [Jon96] with parameterized signatures since in this framework, a type can only be parameterized by other types. There are at least two ways towards a solution: ffl Force the programmer to always give an explicit signature when defining a module. ffl Extend the system of abstract manifest types to ....

Mark P. Jones. Using parameterized signatures to express modular structures. In 23rd Symposium on Principles of Programming Languages. ACM Press, 1996. To appear.

.... Harper and Lillibridge [26, 33] and Leroy [32] Harper, Mitchell, and Moggi devised the phase distinction to show the decidability of type checking for the ML module system [27] Jones shows how to avoid much of the complexity of typing ML style modules via higher order (parametric) signatures [30, 29]. 5.5 Types vs. Concatenation and Extension for Records and Objects. When we extend our system with types, we will closely consider previous work on types for record concatenation [42, 28] extensible records [38, 22] and extensible objects [19, 39, 10] ....

M. P. Jones. Using parameterized signatures to express modular structure. In Conf. Rec. POPL '96: 23rd ACM Symp. Principles of Prog. Languages, 1996.

....in reasoning about the phase distinction [HMM90] Our work will eventually have to deal with this issue. In a slightly different vein than the work just mentioned, Jones showed that much of the complexity of typing ML style modules could be avoided by allowing higher order (parametric) signatures [Jon96, Jon95]. 5.5 Types vs. Concatenation and Extension for Records and Objects In extending our system to deal with types, it will probably be very helpful to consider the extensive literature on handling types for record concatenation [Wan89, HP91, R em93b, R em95] types for extensible records [R em93a, ....

Mark P. Jones. Using parameterized signatures to express modular structure. In Conf. Rec. POPL '96: 23rd ACM Symp. Principles of Prog. Languages, 1996.

.... been described by Laufer and Jones among others, lifting this restriction for a constructor type naturally leads to a system with support for local existential quantification, while the corresponding generalization for selector types is best interpreted as local universal quantification [Lau92, Jon96, Jon97] Taking this idea further, by also letting the declared sub supertypes contain free variables, opens up some interesting possibilities to explore (recall that the implied subtype axioms remain valid in spite of this change) For one thing, a term can now be assigned an existentially ....

M.P. Jones. Using Parameterized Signatures to Express Modular Structure. In ACM Principles of Programming Languages, St Petersburg, FL, January 1996. ACM Press.

....such as Modula 3 are fundamentally structured around the idea of a module. Standard ML provides a small typed language on top of the core language explicitly for handling modular structures. All of these mechanisms are attempts to provide support in some way for programming in the large. Jones [Jon96] identifies three major issues that a module system needs to address: 1. The need to provide a way of organizing code into distinct units in a coherent way to facilitate code and namespace management. 2. Providing abstraction barriers to lessen the dependence of units on the implementation ....

Mark P. Jones. Using parameterized signatures to express modular structure. In 23rd ACM Symp. Principles of Programming Languages, pages 68--78, 1996.

....conditions allowing to extend this base language with modules (one may especially think of the Calculus of Constructions with Inductive Types and the associated reduction, or of the Calculus of Constructions with fij equivalence rule for conversion. 3 It should be noticed that Jones [Jon96] proposed a way to solve this problem in a programming language with records and the ability to define abstract types, but this approach applies only in system where polymorphism is implicit and where types do not depend on terms. 16 Finally, possible extensions of our system have to be ....

Mark P. Jones. Using parameterized signatures to express modular structures. In 23rd Symposium on Principles of Programming Languages. ACM Press, 1996. To appear.

....property of ML style modules. The SML 90 module language, however, contains several major problems; for example, type abbreviations are not allowed in signatures, opaque signature matching is not supported, and modules are first order only. These problems were heavily 10 researched [12, 19, 20, 23, 36, 25, 17] and mostly resolved in SML 97 [27] The main remaining issue is to design a higher order module calculus that satisfies all of the properties mentioned in the beginning of this paper (see Section 1.2) Supporting higher order functors with fully syntactic signatures turns out to be a very hard ....

M. P. Jones. Using parameterized signatures to express modular structure. In Twenty-third Annual ACM Symp. on Principles of Prog. Languages, pages 68--78, New York, Jan 1996. ACM Press.

....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. Nevertheless, many recent papers [21,22,6,12,19,20,24,9,10] have shown that many of the modular mechanisms provided by them turn out to be inadequate in the light of the new software technology. Object oriented and distributed programming have promoted a stronger demand for more flexible modularization mechanisms able to face the problem of software ....

....but not with more general type constraints like subtyping; furthermore, the choice of the specific FPC institution prevents from defining module systems over arbitrary core languages. Finally, many other interesting theoretical papers can be found about modularization and separate type checking [17,16,21,22,20,33]. However, this paper differs from them since it proposes a general framework bound to neither any particular language nor type system and able to embody some of the techniques proposed in them. For instance, the several subtyping relations on polymorphic constrained types defined in [33] in the ....

M. P. Jones. Using parameterized signatures to express modular structure. In Proc. 23rd ACM Symp. on Principles of Programming Languages, pages 68--78, St. Petersburg Beach, Florida, Jan 1996. ACM Press.

....typing (inferring module signatures) and static semantics (lexical scoping of identifiers) of the resulting language in unforeseeable ways. In an attempt to provide a less complex type theoretic framework for modular programming (compared with extensions of SML s module system) Jones [Jon95, Jon96] proposed a module system in which modules are modeled by first class records structures. He claimed that his intermediate language is a useful and powerful language in its own right , and we interpret his work as an attempt to use records for modularization on the level of the programming ....

.... in particular) There are, however, proposals to establish further language support for modular programming below the level of the simple module system by providing first class record structures in the programming language, together with the necessary extensions to the type language [Jon95, Jon96, JJ96] In other words, Haskell seems to drift towards the situation symbolized in the left hand side of figure 8.3, with a simple module language M 2 at the top of its hierarchy and a sophisticated second module language below the type language. Standard ML, on the other hand, has a rather ....

[Article contains additional citation context not shown here]

Mark P. Jones. Using Parameterized Signatures to Express Modular Structure. In Proceedings of the Twenty Third Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, St. Petersburg Beach, Florida, January 21-24 1996.

....phase distinction property of ML style modules. The SML 90 module language, however, contains several major problems; for example, type abbreviations are not allowed in signatures, opaque signature matching is not supported, and modules are first order only. These problems were heavily researched [HL94, Ler94, Ler95, Lil97, Tof92, MT94, Jon96] and mostly resolved in SML 97 [MTHM97] The main remaining issue is with the design of higher order modules, with proposals ranging from fully transparent ones [MT94] to applicative functors [Ler95, Cou97] or abstract functors [HL94, Ler94, Lil97] Fully transparent modules are most expressive, ....

Mark P. Jones. Using parameterized signatures to express modular structure. In Twenty-third Annual ACM Symp. on Principles of Prog. Languages, pages 68--78, New York, Jan 1996. ACM Press.

....has been considered since the early 70s an essential principle for managing the complex task of software development [30] Nowadays there exist many programming languages supporting the notion of module and offering rather advanced features for modularization. Nevertheless, many recent papers [22,23,6,12,19,20,25,9,10] have shown that many of the modular mechanisms provided by them turn out to be inadequate in the light of the new software technology. Object oriented programming and distributed systems have promoted a stronger demand for more flexible modularization mechanisms able to face the problem of ....

....but not with more general type constraints like subtyping; furthermore, the choice of the specific FPC institution prevents from defining module systems over arbitrary core languages. Finally, many other interesting theoretical papers can be found about modularization and separate type checking [17,16,22,23,20,34]. However, this paper differs from them since it proposes a general framework bound to neither any particular language nor type system and able to embody some of the techniques proposed in them. For instance, the several subtyping relations on polymorphic constrained types defined in [34] in the ....

M. P. Jones. Using parameterized signatures to express modular structure. In Proc. 23rd ACM Symp. on Principles of Programming Languages, pages 68--78, St. Petersburg Beach, Florida, Jan 1996. ACM Press.

....of type sharing as in the strong sum based approaches. To achieve this new interpretation, we view each signature declaration as defining a parameterized type template of form s : K:M where s is a higher order constructor variable, K is a kind, and M is a module type; we borrow from Mark Jones [14] and name such templates as parameterized signatures. 1 When we use the signature to type an opaque module, we assign the module with type 9s : K:M . When we use the signature to constrain a functor argument X, we consider that the functor not only binds a module X but also binds a higher order ....

....semantics of our higher order modules. From the typing rules for KMC, we show that all KMC module expressions have unique type signatures. The KMC calculus can also be easily integrated with languages other than ML where module expressions do not follow the ML like signature syntax [14]. Based on the semantics of KMC, we then present an External Module Calculus (EMC) designed for the ML like 1 Although our notion of parameterized signatures is not precisely same as the one used by Jones [14] we do share the same philosophy of using parameterized type constructors to model ....

[Article contains additional citation context not shown here]

M. P. Jones. Using parameterized signatures to express modular structure. In Twenty-third Annual ACM Symp. on Principles of Prog. Languages, pages 68--78, New York, Jan 1996. ACM Press.

....lambda bound, and thus subject to monomorphic instantiation only. The net result is that communication interfaces can only be shared between objects that have the same internal state type There might be several ways out of this dilemma, including the first class structures proposed by Mark Jones [Jon96], or the use of explicit, polymorphic coercion functions that get the static typings right but behave as the identity function at runtime. We have found, though, that the object oriented concept of subtyping solves the problem very neatly, and we will present our program examples in the next ....

M.P. Jones. Using Parameterized Signatures to Express Modular Structure. In ACM Principles of Programming Languages, St Petersburg, FL, January 1996. ACM Press.

....School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA. 2 With strong language support for modules it should be possible to change the implementation of a type without changing its public interface and without requiring recompilation of other modules which import it. See [Jon96] for a more detailed discussion of modules. Object oriented languages like Eiffel, Smalltalk, and Java use classes as compilation boundaries as well as for name space management, making it appear that classes can play the same role as modules. With [Szy92] however, we believe that this ....

Mark P. Jones. Using parameterized signatures to express modular structure. In 23rd ACM Symp. Principles of Programming Languages, pages 68--78, 1996.

....of writing we have only just begun to establish the formal properties of our system. We have, however, implemented a prototype interpreter which is available for download, and hope to merge these extensions into GHC, a production Haskell compiler. 2 Concrete Modules as Records Following Jones [6], we encode interfaces as parameterised record types, and implementations as records. Haskell already has some record like syntax for data constructors with named arguments, and many Haskell implementations allow these elds to be assigned a polymorphic type. However, our 1 requirements are more ....

....non nested declarations. For example, our BTSet declaration may be rewritten: data BTSet BinTree a = BTSet Leaf BTSet Node (BTSet BinTree a) a (BTSet BinTree a) record BTSet a = empty : BTSet BinTree a cmp : a a BTSet Cmp add : a BTSet BinTree a BTSet BinTree a Jones [6] advocates not supporting nested types on the grounds that they may always be translated away in this manner. We support them in our system because they are convenient, they subsume the usual namespace mechanism, and they turn out to be easily implemented. 3 3 Abstract Modules and Existentials ....

[Article contains additional citation context not shown here]

M. P. Jones. Using parameterized signatures to express modular structure. In Proceedings of the 23rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, St. Petersburg Beach, Florida, pages 68-78. ACM Press, Jan. 1996.

....type information to the places where it is needed, but the mechanisms that we need to support this are rather di erent from the mechanisms that are used to support the current Hugs and GHC extensions illustrated above. One promising approach, previously used in work with parameterized signatures [Jon96], is to use socalled has predicates for records instead of the lacks predicates used here. The advantage of the has predicate approach is that it provides a looser coupling between records and their component types, and delays the need to resolve these predicates to a point where more ....

M.P. Jones. Using parameterized signatures to express modular structure. In 23rd ACM Symposium on Principles of Programming Languages (POPL'96), pages 68-78. ACM, St Petersburg Beach, Florida, January 1996.

....type information to the places where it is needed, but the mechanisms that we need to support this are rather different from the mechanisms that are used to support the current Hugs and GHC extensions illustrated above. One promising approach, previously used in work with parameterized signatures [Jon96], is to use socalled has predicates for records instead of the lacks predicates used here. The advantage of the has predicate approach is that it provides a looser coupling between records and their component types, and delays the need to resolve these predicates to a point where more ....

M.P. Jones. Using parameterized signatures to express modular structure. In 23rd ACM Symposium on Principles of Programming Languages (POPL'96), pages 68--78. ACM, St Petersburg Beach, Florida, January 1996.

No context found.

Mark P. Jones. Using parameterized signatures to express modular structure. In POPL '96.

No context found.

Mark P. Jones. Using parameterized signatures to express modular structure. In POPL '96.

No context found.

M. P. Jones. Using parameterized signatures to express modular structure. In Proc. 23rd ACM Symp. on Principles of Programming Languages, pages 68--78, St. Petersburg Beach, Florida, Jan 1996. ACM Press.

No context found.

Mark P. Jones. Using parameterized signatures to express modular structure. In Conf. Rec. POPL '96: 23rd ACM Symp. Principles of Prog. Languages, 1996.

First 50 documents

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC