R. Harper, R. Milner, and M. Torre. A type discipline for program modules. In TAPSOFT 87, volume 250 of LNCS, pages 308-319. Springer-Verlag, 1987.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....any other type, including types with the same structure. From this, it is tempting to explain type abstraction in terms of generativity of type declarations and say for instance that a type is abstract because it is created each time its defi nition is evaluated . The )ef itio of ttmdard A [ [14, 8] formalizes this approach as a calculus over type stamps that defines when new types are generated and when old types are propagated. This approach is adequate for specifying a type checker, but too low level and operational in nature to help understanding type abstraction and reason about ....

R. Harper, R. Milner, and M. Torre. A type discipline for program modules. In TAPSOFT 87, volume 250 of LNCS, pages 308-319. Springer-Verlag, 1987.

....[13] obvious. The well known inadequacies of weak sums for modular programming [15] are here offset by the extra expressiveness brought by manifest types. The present paper also puts forward a new way to account for type sharing, distinct from the heavy graph based formalism of the Definitzon [11, 17, 25] and from Aponte s record based module algebra [1] Previous approaches to sharing focus on structure generativity and sharing between structures; as a consequence, they require stamps over structures and consistency conditions between structures having the same stamp. In contrast, sharing ....

....structures: to specify sharing between all type components of two structures in a compact way. A more advanced use of sharing constraints over structures is to ensure that the value components of the structures are also identical, which is useful to deal with structures that have a local state [11]. This can be encoded to some extent in our calculus, by introducing an abstract type to act as a structure stamp. For instance, the SML specification (structure A: sig val r: int ref . end structure B: sig val r: int ref . end sharing A = B) becomes (structure A: sig type stamp; val r: ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT 87, volume 250 of Lecture Notes in Computer Sczence, pages 308-319. Springer-Verlag, 1987.

....core language, and therefore provides a starting point to build module systems for many different programming languages. Previous work on the static semantics of SML mod ules had been based on special purpose term algebras to represent modules and on specific and complex static semantic notions [3, 7, 6], or does not address sharing nor multiple views of modules [4] We show here that, this static description can be completely expressed by classical typing techniques such as polymorphic typing and the techniques developed to type extensible Author s address: INRIA Roquencourt, Projet Formel, ....

....as a structure where stamps are universally quantified variables. Roughly speaking, one can consider structure and signature types in modules, respectively as the equivalent of simple types and type schemes in the core language. This elegant analogy was first proposed by Harper, Milner and Tofte [3] when describing the semantics of SML modules. Figure 2 shows a representation of the signature . The dashed circles stand for universally quantified stamps: x and y in this example. Harper, Milner and Tofte [3, 7] and Tofte [11] devel oped several static semantic descriptions of SML modules ....

[Article contains additional citation context not shown here]

Robert Harper, Robin Milner, and Mads Tofte. A type discipline for program modules. In Theory and Practice of Programming Languages, volume 250 of Lecture Notes in Computer Science. Springer Verlag, 1987.

....The implementation of modules in this new compiler went through two generations. A first version was done in the fall of 1986, but it was completely rewritten in the summer of 1987 following discussions of the operational static semantics of modules with Robin Milner, Mads Tofte, and Bob Harper [6,7,12]. Like Harper s prototype implementation, the new modules implementation was inspired by the static semantics, but it uses a structure sharing strategy [3,13] to avoid serious performance problems associated with a naive implementation of the static semantics. Although precise comparative ....

....the existence of the module constructs they have been reduced to common notions of records and functions. 3.2. Static Representations A naive representation of signatures and structures can be modeled more or less directly on the semantic constructs used in the operational static semantics [5,6]. There a structure is modeled by an environment E that maps component identifiers to the appropriate sort of static binding (type, structure, variable, etc. and a stamp, n, that uniquely identifies the structure: str = n,E) We can view a structure as a tree or dag with nodes labeled by ....

[Article contains additional citation context not shown here]

R. Harper, R. Milner, and M. Tofte, A type discipline for program modules, Proceedings TAPSOFT 87, LNCS Vol, 250, Springer-Verlag, New York, 1987, 308-319.

....any other type, including types with the same structure. From this, it is tempting to explain type abstraction in terms of generativity of type declarations and say for instance that a type is abstract because it is created each time its de nition is evaluated . The De nition of Standard ML [14, 8] formalizes this approach as a calculus over type stamps that de nes when new types are generated and when old types are propagated. This approach is adequate for specifying a type checker, but too low level and operational in nature to help understanding type abstraction and reason about ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT 87, volume 250 of LNCS, pages 308-319. Springer-Verlag, 1987.

....[13] obvious. The well known inadequacies of weak sums for modular programming [15] are here o set by the extra expressiveness brought by manifest types. The present paper also puts forward a new way to account for type sharing, distinct from the heavy graph based formalism of the De nition [11, 17, 25] and from Aponte s record based module algebra [1] Previous approaches to sharing focus on structure generativity and sharing between structures; as a consequence, they require stamps over structures and consistency conditions between structures having the same stamp. In contrast, sharing ....

....structures: to specify sharing between all type components of two structures in a compact way. A more advanced use of sharing constraints over structures is to ensure that the value components of the structures are also identical, which is useful to deal with structures that have a local state [11]. This can be encoded to some extent in our calculus, by introducing an abstract type to act as a structure stamp. For instance, the SML speci cation (structure A: sig val r: int ref . end structure B: sig val r: int ref . end sharing A = B) becomes (structure A: sig type stamp; val r: ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT 87, volume 250 of Lecture Notes in Computer Science, pages 308-319. Springer-Verlag, 1987.

....is, functions that can be applied to arguments of only one type. This requires, for example, that it must be defined an identity function, of type of type , for each type , although the definition of this function is the same for values of any type. In some languages, such as Standard ML [MHT87] or simply ML) it is possible to define polymorphic functions, that is, functions that operate uniformly over different type arguments. The mechanism used to define polymorphic functions in ML is a very simple and elegant extension of simply typed calculus. 4.1 core ML In ML type system, ....

J. Mitchell, R. Harper, and M. Tofte. A type Discipline for Program Modules. Lecture Notes in Computer Science, 250, 1987.

.... calculus there is a very simple (and natural) definition of equality, namely e 1 = e 2 iff both e 1 and e 2 exist and they are equivalent, which can be safely used at compile time to check whether two program units share a common component, as required for checking a sharing constrain in ML (see [HMT87]) While up to now the correctness of a type checking has to be proved by looking at the details of the operational semantics. Acknowledgements My thanks to M. Hyland, A. Kock (and other participants to the 1988 Category Theory Meeting in Sussex) for directing me towards the literature on monads ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In Proc. of TAPSOFT 87 (Pisa 1987), volume 250 of LNCS. Springer Verlag, 1987.

....by their names; uniqueness of names is ensured by suitable syntactic restrictions or by renamings. Unfortunately, this simple approach does not extend easily to more powerful module and type abstraction systems, in particular those that feature parameterized abstractions, known as functors in SML [13, 7]. The main reason is that if the result of a functor contains a generative type declaration, then a new type must be generated for each application of the functor. Otherwise, two different structures obtained by applying a functor to two different arguments would have compatible type components ....

....result type must be preserved. Second, we should also account for SML s sharing constraints: the mechanism by which a functor with several arguments can require that some type components of its arguments are actually the same type, or in other terms that they have been generated at the same time [13, 7]. Therefore, a theory of type generativity must not go too far and e.g. systematically generate new types for all functor applications. Instead, it should maintain a suitable notion of type identity, where new types are generated when the programmer requires it, but the identities of existing ....

[Article contains additional citation context not shown here]

Robert Harper, Robin Milner, and Mads Tofte. A type discipline for program modules. In TAPSOFT 87, volume 250 of Lecture Notes in Computer Science, pages 308--319. Springer-Verlag, 1987.

....technique for software programming and reuse. It is also needed for reasoning about programs: especially, it is a major issue of formal methods. In this respect, the SML language is particularly interesting, because of the power of its module language, which is a small typed language of its own [HMT87, HMT90] This module system was designed for use at an interactive toplevel, and therefore separate compilation issues were not addressed. For instance, in order to type check a functor application m 1 (m 2 ) knowing the module types of m 1 and m 2 was not enough: some knowledge of the ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT 87, volume 250 of LNCS, pages 308--319. Springer-Verlag, 1987.

.... c calculus there is a very simple (and natural) de nition of equality, namely e 1 = e 2 i both e 1 and e 2 exist and they are equivalent, which can be safely used at compile time to check whether two program units share a common component, as required for checking a sharing constrain in ML (see [HMT87]) While up to now the correctness of a type checking has to be proved by looking at the details of the operational semantics. Acknowledgements My thanks to M. Hyland, A. Kock (and other participants to the 1988 Category Theory Meeting in Sussex) for directing me towards the literature on monads ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In Proc. of TAPSOFT 87 (Pisa 1987), volume 250 of LNCS. Springer Verlag, 1987.

....Extended ML (EML) framework augments Standard ML s (SML) module declarations, a substructure intended to support programming in the large, to a calculus for specification and refinement. It generalizes the structures (large values) and signatures (large types) of SML to include axiom declarations[3, 1, 2]. In the case of signatures, these axioms are viewed as specifications. In the case of structures they constrain the space of models in a manner consistent with the specification. Axioms are of use in structures during intermediate stages of the refinement process once the structure is fully ....

Robert Harper, Robin Milner, and Mads Tofte. A type discipline for program modules. In TAPSOFT '87, pages 308--319. Springer-Verlag, March 1987.

....in so as to understand them independently of their possible interactions with other language features. This is not to say that other features are irrelevant or of less interest. In fact, operator overloading [52,118] implicit and explicit type coercions [103,78,27] abstract and dependent types [82,69,34], recursive types [110,70,77] and especially inclusion polymorphism [10,11,112,50,98,121,122] a type theoretic view of the behavior of object oriented programming languages, are significant in the typing disciplines of modern strongly typed programming languages (e.g. 99,12] But we cannot ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In Proc. Int'l Joint Conf. on Theory and Practice of Software Development (TAPSOFT), pages 308--319, SpringerVerlag, Mar. 1987. Lecture Notes in Computer Science, Vol. 250.

....The implementation of modules in this new compiler went through two generations. A first version was done in the fall of 1986, but it was completely rewritten in the summer of 1987 following discussions of the operational static semantics of modules with Robin Milner, Mads Tofte, and Bob Harper [6,7,12]. Like Harper s prototype implementation, the new modules implementation was inspired by the static semantics, but it uses a structure sharing strategy [3,13] to avoid serious performance problems associated with a naive implementation of the static semantics. Although precise comparative ....

....the existence of the module constructs they have been reduced to common notions of records and functions. 3.2. Static Representations A naive representation of signatures and structures can be modeled more or less directly on the semantic constructs used in the operational static semantics [5,6]. There a structure is modeled by an environment E that maps component identifiers to the appropriate sort of static binding (type, structure, 5 variable, etc. and a stamp, n, that uniquely identifies the structure: str = n , E) We can view a structure as a tree or dag with nodes ....

[Article contains additional citation context not shown here]

R. Harper, R. Milner, and M. Tofte, A type discipline for program modules, Proceedings TAPSOFT 87, LNCS Vol. 250, Springer-Verlag, New York, 1987, 308-319.

....of signature matching, where a declaration such as structure S : sig1 = S may cause a partial copy of S to be constructed and bound to S . 3.6.3. Structure sharing The final approach is inspired, like Harper s prototype implementation, by the semantic model developed by Harper, Milner, and Tofte[15]. We return to the straightforward idea of actually performing the static reductions to obtain instantiated copies of the functor body, but a structuresharing representation is used to minimize the amount of copying. In this representation, which is similar in principle to the structure sharing ....

Robert Harper, Robin Milner, and Mads Tofte, "A type discipline for program modules," ECSLFCS -87-28, Univ. of Edinburgh, 1987.

....in the sense that it could be lost after a reimplementation of the given module. Therefore, it helps isolating modules one from each other. 1. 1 Standard ML The Standard ML language is particularly interesting, with respect to the modularity concerns because of the power of its module system [HMT87,HMT90]. Indeed, this system allows the definition and use of parameterized modules. This notion of parameterized modules allows to plug a module into another one. For instance, a module defining balanced trees over an ordered type can be parameterized by a module defining a type and a comparison ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT 87, volume 250 of LNCS, pages 308--319. Springer-Verlag, 1987.

....will vary for each of the calculi that we consider, but the general pattern remains the same. This paper is organized as follows. In Section 2 we define the system CC , and state some of its important properties. In Section 3 we introduce an operational presentation of CC , following [46, 21, 20, 42, 18] (among others. The significance of the operational presentation is that it provides a normal form for typing derivations that is exploited by the type synthesis algorithm. In Section 4 we present a type synthesis and conversion algorithm for CC in the natural semantics style of [7] This ....

Robert Harper, Robin Milner, and Mads Tofte. A type discipline for program modules. In TAPSOFT '87, volume 250 of Lecture Notes in Computer Science. Springer-Verlag, March 1987.

....Program units are represented as structures that are linked together by the use of functors. The coherence of a combination of program units is ensured by the use of sharing speci cations. There are two existing analyses of the module system, each elucidating several important features. In [HMT87b, HMT87a, Tof87] a formal analysis of the Standard ML type system is given, using structured operational semantics to describe the computational behavior of the type checker. While it gives a precise, implementation independent characterization of the ML type system, this approach is not ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT '87, volume 250 of LNCS. Springer-Verlag, March 1987.

....are no functors with functor parameters. In this respect, the current language only uses first order modules. There are two formal analyses of the module system, one operational and the other a syntactic translation leading to a denotational semantics. The structured operational semantics of [HMT87b, HMT87a, Tof87] includes a computational characterization of the type checker. This gives a precise, implementation independent definition of the Standard ML language that may be used for a variety of purposes. The second formal analysis is a type theoretic description of ML, which leads to a ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT '87, volume 250 of LNCS. Springer-Verlag, March 1987.

....terms that represent e#ects. Similar situations have been studied for other type systems. Typically, terms which represent finite sets or finite maps are paired with some kind of variable which identifies the set or map in question. This is the situation in the semantics of ML structure sharing [Harper et al. 1987; Tofte 1988; Aponte 1993] where structure names are paired with environments) in record typing [Remy 1989] where row variables are paired with record types) and in type systems for polymorphic references [Leroy 1992] where closure type variables are paired with sets of type schemes) In this ....

Harper, R., Milner, R., and Tofte, M. 1987. A type discipline for program modules. In Proceedings of the International Joint Conference on Theory and Practice of Software Development (TAPSOFT). Lecture Notes in Computer Science, vol. 250. Springer-Verlag, Berlin, 308--319.

....and instead regard structures as providing a unique signature describing each component. In this sense we regard signature matching as a convenience similar to that afforded by the type inference algorithm for the core language. For further discussion of signature matching, we refer the reader to [HMT87, Tof88, MTH90] Discussion of ML sharing specifications is deferred to Section 9.3 below. Functors (which are functions mapping structures to structures) are introduced using a syntax similar to that found in many programming languages: functor F ( S : SIG ) SIG = struct type t = S.t S.t ....

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT '87, Berlin, 1987. Springer LNCS 250.

No context found.

R. Harper, R. Milner, and M. Tofte. A type discipline for program modules. In TAPSOFT '87, Berlin, 1987. Springer LNCS 250.

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