D. MacQueen. An implementation of standard ML modules. In Proceedings of the ACM Conference on LISP and Functional Programming, pages 212--223, Snowbird, Utah, 1988.  Home/Search   Document Details and Download   Summary   Related Articles   Check

....and therefore the system supports higher order modules and some object oriented This work was sponsored by the Advanced Research Projects Agency, CSTO, under the title The Fox Project: Advanced Development of Systems Software , ARPA Order No. 8313, issued by ESD AVS under Contract No. F19628 91 C 0168. IElectronic mail address: rhcs. cmu. edu. Electronic mall address: mdlcs. cmu. edu. Perm ss;on to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage. the ACM copyright notice end the title of ....

....in the semantics are the use of unique names (or generativity ) to handle abstraction and sharing specifications, and the use of non deterministic rules to handle polymorphism, sharing specifications, and signature matching. The static semantics has proved useful as a guide to implementa tion [28, 2, 41, 40] but is remarkably difficult to modify 2 It seems plausible that most uses of type sharing specifications may be accounted for in this way, provided that we neglect local specitications and re binding of variables in specifications, both of which are of questionable utility. 125 or ....

[Article contains additional citation context not shown here]

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988.

....safer and more efficient because the constructed logic can be compiled to produce a fully automatic theorem prover. We have listed a number of logic functors, but many others can be built. 6. 1 Related works Our use of the word functor is similar to ML s one for designating parameterized modules [Mac88] However, our logic functors are very specialized contrary to functors in ML which are general purpose (in short, we have fixed the signature) and they carry a semantic component. Both the specialization and the semantic component allow us to express composition conditions that are out of the ....

D.B. MacQueen. An implementation of Standard ML modules. In LISP and Functional Programming, pages 212--223, 1988.

....in the semantics are the use of unique names (or generativity ) to handle abstraction and sharing specifications, and the use of non deterministic rules to handle polymorphism, sharing specifications, and signature matching. The static semantics has proved useful as a guide to implementation [28, 2, 41, 40], but is remarkably di#cult to modify It seems plausible that most uses of type sharing specifications may be accounted for in this way, provided that we neglect local specifications and re binding of variables in specifications, both of which are of questionable utility. or extend (see, for ....

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988.

....language [MTH90, chapter 7] is relatively simple. At present the ML Kit system does not compile phrases of the Standard ML module language into the typed lambda language described in section 11. Literature regarding implementation of the Standard ML module system includes [App92, AM87, AM91, Mac88] The declaration compiler of the core language in the ML Kit system is implemented in monadic style [Wad92] A similar technique can be used in an implementation of the top level declaration (topdec) compiler. In this chapter we first discuss how constructs of the module language can be ....

David B. MacQueen. An implementation of standard ml modules. Technical report, AT&T Bell Laboratories, Murray Hill, NJ 07974, March 1988.

....key for retrieving functions. Integrating a tool based on these ideas in our environment would constitute a natural complement to our menu driven construction where only syntactic considerations are used to proposed items in the menu. Second, modular construction proned by ML designers in [15, 16] could clearly benet to our structured approach of an environment. However we have refrained our investigations in that area since so far no consensus has been reached in the ML community to dene what a good module for ML should be. Support tools that could be developed for a particular ....

David B. MacQueen. The implementation of Standard ML modules. In ACM Conf. on Lisp and Functional Programming, pages 21223, New York, 1988. ACM Press.

....it defines. Unlike packages or clusters, a Rascal style module is structurally no different from a record: it is defined in terms of a collection of bindings projected from a dynamically instantiated environment. In this respect, Rascal modules shares some functionality with modules defined in ML [MacQueen 1988] as in Rascal, there is no special runtime representation for modules in ML; modules are represented in terms of ordinary records and function closures. However, a Rascal style module is a first class object; both the stack procedure as well its instances are treated no differently from any ....

MacQueen, D. 1988. An implementation of standard ML modules. In Proc. of the ACM Symp. on Lisp and Functional Programming, ACM, New York, 212--223.

....[24] also provide support for modules; however, the semantics of modules in these systems requires them to be statically defined at the top level and necessitates non trivial syntactic and semantic extensions to express parameterized modules. In the case of languages such as Haskell [10] or SML [19, 18], the semantics and implementation of modules is also closely tied to a static type system. We address these concerns by giving users great flexibility to manipulate environments, and to constrain the extent and scope of the environment reification process. We argue that the techniques and ....

....defines the set of names (potentially along with their types) that are visible to the outside. The set of bindings associated with a given signature defines the module interface. Depending on the semantics desired, a module could be instantiated multiple times (e.g. as in Scheme 48 [12] or ML [18]) or only once (e.g. as in Ada [24] or Clu [17] In high level programming languages such as Scheme [4] ML [19] or Haskell [10] the exclusive use of lexical binding and the absence of abstractions to construct and manipulate namespaces necessitates the inclusion of a module facility as part of ....

[Article contains additional citation context not shown here]

David MacQueen. An Implementation of Standard ML Modules. In Proceedings of the ACM Symposium on Lisp and Functional Programming, pages 212-- 223, 1988.

....lists of booleans by first instantiating ff to bool , to conclude that append also has the type bool list bool list bool list . Standard ML is a language with parametric polymorphism that has been developed for at least 15 years [Mil78, MTH90, MT91b, Har86, HMM 88, Tof87, Tof88, DM82, Mac88] practical implementations are freely available. Standard ML has the added advantage that the polymorphism is implicit, which means that no types need be mentioned in the definition of functions such as append; instead, they can all be inferred. Refinement type inference simply uses polymorphic ....

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988 ACM Conference on LISP and Functional Programming, Snowbird, Utah, pages 212--223. ACM Press, July 1988. BIBLIOGRAPHY 309

....compilers from specifications written in natural semantics. Even at the level of hand written compilers, the formal semantics is critically important: the data structures used in the Standard ML of New Jersey compiler front end mirror the semantical structures used in the definition of Standard ML [23, 25]. The Edinburgh kit compiler for Standard ML, currently under development, is directly based on the formal semantics, and will therefore be an invaluable tool in experimenting with variations on the language. More generally, semantics based techniques are of increasing importance in compiler ....

David B. MacQueen. An implementation of standard ML modules. In Proceedings of the 1988 ACM Conference on LISP and Functional Programming, 1988.

....and illustrating how it addresses the problems described above. The key language construct we add to support type abstraction in C and to allow separating subtyping from inheritance is called a signature. Signatures in our C extension are related to types in Russel [15] signatures in ML [24, 25], type classes in Haskell [20] definition modules in Modula 2 [36] interface modules in Modula 3 [11] abstract types in Emerald [8] type modules in Trellis Owl [28] categories in Axiom [21] and its predecessor Scratchpad II [34, 35] and types in POOL I [4] In this section, we specify syntax ....

....and code reuse. We proposed language constructs for specifying and working with signature types. These constructs allow us to decouple subtyping from inheritance. The result, C with signatures, has a type system related to those of several other modern programming languages. Similarly as in ML [24, 25], Modula 2 [36] and Modula 3 [11] signatures in C allow a clean separation of specification and implementation. However, ML and Modula 2 only have modules and no classes, while Modula 3 has both classes and modules but provides interfaces for modules only and not for classes. Russel [15] and ....

David B. MacQueen. "An implementation of Standard ML modules." In Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, Snowbird, Utah, 25--27 July 1988. Association for Computing Machinery, pp. 212--223.

....illustrating how it addresses the problems described above. The key language construct added to support type abstraction in C and to allow separating subtyping from inheritance is called a signature. Signatures, in this language extension, are related to types in Russell [16] signatures in ML [25, 26], type classes in Haskell [17] definition modules in Modula 2 [37] interface modules in Modula 3 [12] abstract types in Emerald [9] type modules in Trellis Owl [29] categories in Axiom [22] and its predecessor Scratchpad II [35, 36] and types in POOL I [4] In this section, we specify ....

....and code reuse. We proposed language constructs for specifying and working with signature types. These constructs allow us to decouple subtyping from inheritance. The result, C with signatures, has a type system related to those of several other modern programming languages. Similarly as in ML [25, 26], Modula 2 [37] and Modula 3 [12] signatures in C allow a clean separation of specification and implementation. However, ML and Modula 2 only have modules and no classes, while Modula 3 has both classes and modules but provides interfaces for modules only and not for classes. Russell [16] and ....

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, pages 212--223, Snowbird, Utah, 25--27 July 1988. Association for Computing Machinery.

....separate compilation, which is also highly independent of the base language. The emphasis is on separate compilation rather than on module languages; in particular, functors are not considered. On the implementation side, MacQueen describes the New Jersey ML implementation of the SML module system [17] and its extension to higher order functors [5] Both implementations are considerably more sophisticated than the implementation described in this paper, in particular because much attention is paid to reducing memory requirements through term sharing. MacQueen s implementations follow the ....

....The nondep functions proceed essentially as in CTyping.nondeptype. 4 Compilation We have concentrated so far on the problem of type checking the module language. We now sketch briefly its compilation, which is mostly standard and builds on the type information gathered during module typing [17]. Inria A modular module system 25 Structures are naturally represented as records (tuples) of values and sub structures, obtained by erasing all type fields. Access to structure fields is either by name (similar to a method lookup in an object) or, more efficiently, at fixed offsets determined ....

David B. MacQueen. The implementation of Standard ML modules. In Lisp and Functional Programming 1988, pages 212--223. ACM Press, 1988.

....is also a subtype relationship, and to disallow inheriting only a portion of the superclass. 3 Syntax and Semantics of the Signature Language Extension We term the key language construct we add to C to support type abstraction a signature. It is related to types in Russel [11] ML s signatures [19, 20], Haskell s type classes [16] definition modules in Modula 2 [26] interface modules in Modula 3 [8] abstract types in Emerald [6] type modules in Trellis Owl [21] categories in Axiom [17] and its predecessor Scratchpad II [24, 25] and types in POOL I [3] The type system of C with ....

David B. MacQueen. "An implementation of Standard ML modules." In Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, Snowbird, Utah, 25--27 July 1988. Association for Computing Machinery, pp. 212--223.

....construct we add to C to support type abstraction a signature. A signature declaration defines an abstract type by specifying the member functions that any implementation of the abstract type needs to have. The signature language construct is related to types in Russell [10] ML s signatures [17, 18], Haskell s type classes [11] definition modules in Modula 2 [24] interface modules in Modula 3 [7] abstract types in Emerald [4] type modules in Trellis Owl [19] categories in Axiom [15] and its predecessor Scratchpad II [22, 23] and types in POOL I [1] To associate an implementation ....

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, pages 212--223, Snowbird, Utah, 25--27 July 1988. Association for Computing Machinery.

....in the semantics are the use of unique names (or generativity ) to handle abstraction and sharing specifications, and the use of non deterministic rules to handle polymorphism, sharing specifications, and signature matching. The static semantics has proved useful as a guide to implementation [28, 2, 41, 40], but is remarkably difficult to modify 2 It seems plausible that most uses of type sharing specifications may be accounted for in this way, provided that we neglect local specifications and re binding of variables in specifications, both of which are of questionable utility. or extend (see, ....

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988 ACM Conference on LISP and Functional Programming, Snowbird, Utah, pages 212--223. ACM Press, July 1988.

....support parameterized polymorphism at the level of packages only. That is, packages should be parameterized by packages. FOOPS [9, 2] first suggested this approach, using large grain structuring concepts originated from Clear [4] and later implemented in OBJ [8] and, partially, in Standard ML [14], Ada and other languages. Based on the design of FOOPS, we propose a conservative extension of Java, called PJava, with support for parameterized packages. We claim that Java s capabilities for reuse and maintenance in the large can be significantly enhanced in this way. Furthermore we argue that ....

David MacQueen. The implementation of Standard ML modules. In ACM Conf. on Lisp and Functional Programming, pages 212--23, New York, 1988. ACM Press.

....names. For a class to conform to a signature, the class needs to define the same property names. POOL I offers constructs to automatically create get value and or put value methods for fields declared in a class. 3. 9 ML ML [25, 26] is an eager functional language with an elaborate module system [21, 22] based on the dependent types of Martin Lof s intuitionistic type theory [23] The ML core language, i.e. ML without modules, offers a restricted form of parametric polymorphism. The restriction is that polymorphic functions cannot be used as arguments to functions. ML compilers infer the types ....

David B. MacQueen. "An implementation of Standard ML modules." In Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, Snowbird, Utah, 25--27 July 1988. Association for Computing Machinery, pp. 212--223.

.... Xavier Leroy (INRIA Rocquencourt) David MacQueen (AT T) John Mitchell (Stanford) Jon Riecke (AT T) and Mads Tofte (Copenhagen) Compiler Technology Much of our work in compiler technology is based on the Standard ML of New Jersey system (SML NJ) developed by Andrew Appel and David MacQueen [8, 80]. This compiler, which is publically available from AT T Bell Laboratories, represents the culmination of over 20 years of research on compilers for functional programming languages. As a research vehicle, SML NJ is convenient because it is written in a modular style, thus making it relatively ....

David B. MacQueen. The implementation of Standard ML modules. In ACM Conference on Lisp and Functional Programming, pages 212--223. ACM, 1988.

....in the semantics are the use of unique names (or generativity ) to handle abstraction and sharing specifications, and the use of non deterministic rules to handle polymorphism, sharing specifications, and signature matching. The static semantics has proved useful as a guide to implementation [28, 2, 41, 40], but is remarkably difficult to modify or extend (see, for example, 43] The naive attempt to enrich signatures as sketched above is incompatible with the crucial principal signature property [31] But it is not clear whether this failure is a symptom of an intrinsic incoherence in the ....

David B. MacQueen. An implementation of Standard ML modules. In Proceedings of the 1988 ACM Conference on LISP and Functional Programming, Snowbird, Utah, pages 212--223. ACM Press, July 1988.

....defined representation of machine instructions as sequences of bits [25] For pids we use 128 bit integers which are also easy to write to files. But our static environments are complex pointer data structures with no easy representation as bit strings. Our representation of static environments [17] (for structures, functors, signatures, functor signatures, types, datatypes, values, fixities, symbol tables, etc. uses 36 different datatypes, many of which have sev eral variants there are a total of 115 variants of these types, with a total of 193 record fields. It is not a triv ial matter ....

David B. MacQueen. The implementation of Standard ML modules. In ACM Conf. on Lisp and Functional Programming, pages 212-23, New York, 1988. ACM Press.

.... of the path, each identifier is translated into the corresponding dynamic access instruction (a record selection index to be applied to the corresponding dynamic structure record) For more details about how identity invariant component specifications are handled in the environment, see [Mac88], which is still reasonably accurate on this point. In the implementation, signatures are stamped for faster signature comparison and to indicate the age of objects during elaboration, but signatures do not have static identities in the semantics. Structures. A structure representation ....

David B. MacQueen. The implementation of Standard ML modules. In ACM Conf. on Lisp and Functional Programming, pages 212--23, New York, 1988. ACM Press.

....defined representation of machine instructions as sequences of bits [25] For pids we use 128 bit integers which are also easy to write to files. But our static environments are complex pointer data structures with no easy representation as bit strings. Our representation of static environments [17] (for structures, functors, signatures, functor signatures, types, datatypes, values, fixities, symbol tables, etc. uses 36 different datatypes, many of which have several variants there are a total of 115 variants of these types, with a total of 193 record fields. It is not a trivial matter ....

David B. MacQueen. The implementation of Standard ML modules. In ACM Conf. on Lisp and Functional Programming, pages 212--23, New York, 1988. ACM Press.

No context found.

D. MacQueen. An implementation of standard ML modules. In Proceedings of the ACM Conference on LISP and Functional Programming, pages 212--223, Snowbird, Utah, 1988.

No context found.

David B. MacQueen, `An implementation of Standard ML modules', Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, Snowbird, UT, 25--27 July 1988, pp. 212--223. Association for Computing Machinery.

No context found.

David B. MacQueen. The implementation of Standard ML modules. In ACM Conf. on Lisp and Functional Programming, pages 212--23, New York, 1988. ACM Press.

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