skip to main content
research-article
Open Access

The history of Standard ML

Published:12 June 2020Publication History
Skip Abstract Section

Abstract

The ML family of strict functional languages, which includes F#, OCaml, and Standard ML, evolved from the Meta Language of the LCF theorem proving system developed by Robin Milner and his research group at the University of Edinburgh in the 1970s. This paper focuses on the history of Standard ML, which plays a central role in this family of languages, as it was the first to include the complete set of features that we now associate with the name “ML” (i.e., polymorphic type inference, datatypes with pattern matching, modules, exceptions, and mutable state).

Standard ML, and the ML family of languages, have had enormous influence on the world of programming language design and theory. ML is the foremost exemplar of a functional programming language with strict evaluation (call-by-value) and static typing. The use of parametric polymorphism in its type system, together with the automatic inference of such types, has influenced a wide variety of modern languages (where polymorphism is often referred to as generics). It has popularized the idea of datatypes with associated case analysis by pattern matching. The module system of Standard ML extends the notion of type-level parameterization to large-scale programming with the notion of parametric modules, or functors.

Standard ML also set a precedent by being a language whose design included a formal definition with an associated metatheory of mathematical proofs (such as soundness of the type system). A formal definition was one of the explicit goals from the beginning of the project. While some previous languages had rigorous definitions, these definitions were not integral to the design process, and the formal part was limited to the language syntax and possibly dynamic semantics or static semantics, but not both.

The paper covers the early history of ML, the subsequent efforts to define a standard ML language, and the development of its major features and its formal definition. We also review the impact that the language had on programming-language research.

References

  1. Alexander Aiken, Manuel Fähndrich, Jeffrey S. Foster, and Zhendong Su. 1998. A toolkit for constructing type- and constraint-based program analyses. In Proceedings of the 2nd International Workshop on Types in Compilation (TIC ’98) (Kyoto, Japan) (Lecture Notes in Computer Science), Vol. 1473. Springer-Verlag, New York, NY, USA (March), 78–96. Google ScholarGoogle ScholarCross RefCross Ref
  2. Universität des Saarlandes 2014. Alice. Universität des Saarlandes, Saarbücken, Germany (July). http://www.ps.uni-saarland. de/alice/ Archived at Internet Archive: https://web.archive.org/web/20200201104850/http://www.ps.uni-saarland.de/ alice/ (1 Feb. 2020 10:48:50)Google ScholarGoogle Scholar
  3. Andrew Appel, David MacQueen, Robin Milner, and Mads Tofte. 1988. Unifying Exceptions with Constructors in Standard ML . Technical Report ECS-LFCS-88-55. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (May).Google ScholarGoogle Scholar
  4. Andrew Appel and David B. MacQueen. 1991. Standard ML of New Jersey. In Programming Language Implementation and Logic Programming (PLILP ’91) (Lecture Notes in Computer Science), J. Maluszynski and M. Wirsing (Eds.), Vol. 528. Springer-Verlag, New York, NY, USA, 1–13. Google ScholarGoogle ScholarCross RefCross Ref
  5. Andrew W. Appel. 1987. Garbage collection can be faster than stack allocation. Inform. Process. Lett. 25, 4 (June), 275–279. Google ScholarGoogle ScholarDigital LibraryDigital Library
  6. Andrew W. Appel. 1989a. Runtime Tags Aren’t Necessary. Journal of Lisp and Symbolic Computation 2, 2 (June), 153–62. Google ScholarGoogle ScholarCross RefCross Ref
  7. Andrew W. Appel. 1989b. Simple Generational Garbage Collection and Fast Allocation. Software – Practice and Experience 19, 2, 171–183. Google ScholarGoogle ScholarCross RefCross Ref
  8. Andrew W. Appel. 1990. A Runtime System. Journal of Lisp and Symbolic Computation 3, 4 (Nov.), 343–380. Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Andrew W. Appel. 1992. Compiling with Continuations. Cambridge University Press, Cambridge, UK.Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Andrew W. Appel. 1993. A critique of Standard ML. Journal of Functional Programming 3, 4 (Oct.), 391–429. Google ScholarGoogle ScholarCross RefCross Ref
  11. Andrew W. Appel. 1994. Proposed interface for Standard ML Stream I/O. Nov. 1994. 24 pages. http://sml-family.org/ history/io.94-11-14.pdf Archived at Internet Archive: https://web.archive.org/web/20200314181846/http://sml-family. org/history/io.94-11-14.pdf (14 March 2020 18:18:46)Google ScholarGoogle Scholar
  12. Andrew W. Appel. 1995. Proposed interface for Standard ML Stream I/O. July 1995. 24 pages. http://sml-family.org/ history/io.95-07-13.pdf Archived at Internet Archive: https://web.archive.org/web/20200315172956/http://sml-family. org/history/io.95-07-13.pdf (15 March 2020 17:29:56)Google ScholarGoogle Scholar
  13. Andrew W. Appel. 1998. Modern Compiler Implementation in ML. Cambridge University Press, Cambridge, UK.Google ScholarGoogle Scholar
  14. Andrew W. Appel, Dave Berry, Emden R. Gansner, Lal George, Lorenz Huelsbergen, Dave MacQueen, and John Reppy. 1994. A New Initial Basis for Standard ML (Draft). March 1994. 74 pages. http://sml-family.org/history/basis-1994-03-05.pdf Archived at Internet Archive: https://web.archive.org/web/20200313180417/http://sml-family.org/history/basis-1994-03-05.pdf (13 March 2020 18:04:17) Draft design document dated March 5, 1994.Google ScholarGoogle Scholar
  15. Andrew W. Appel and Marcelo J. R. Concalves. 1993. Hash-consing Garbage Collection. Technical Report CS-TR-412-93. Department of Computer Science, Princeton University, Princeton, NJ, USA (Feb.).Google ScholarGoogle Scholar
  16. Andrew W. Appel and Lal George. 2001. Optimal Spilling for CISC Machines with Few Registers. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’01) (Snowbird, UT, USA). Association for Computing Machinery, New York, NY, USA (June), 243–253. Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Andrew W. Appel and Trevor Jim. 1989. Continuation-Passing, Closure-Passing Style. In Conference Record of the 16th Annual ACM Symposium on Principles of Programming Languages (POPL ’89) (Austin, TX, USA). Association for Computing Machinery, New York, NY, USA, 293–302. Google ScholarGoogle ScholarDigital LibraryDigital Library
  18. Andrew W. Appel and David B. MacQueen. 1987. A Standard ML Compiler. In Functional Programming Languages and Computer Architecture (FPCA ’87) (Portland, OR, USA) (Lecture Notes in Computer Science), Vol. 274. Springer-Verlag, New York, NY, USA (Sept.), 301–324. Google ScholarGoogle ScholarCross RefCross Ref
  19. Andrew W. Appel and David B. MacQueen. 1994. Separate Compilation for Standard ML. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’94) . Association for Computing Machinery, New York, NY, USA (June), 13–23. Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Andrew W. Appel and Zhong Shao. 1992. Callee-save Registers in Continuation-Passing Style. Journal of Lisp and Symbolic Computation 5 (Sept.), 191–221. Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. David Aspinall. 1995. Subtyping with singleton types. In Proceedings of the 8th Workshop on Computer Science Logic (CSL ’94) (Kazimierz, Poland) (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA (Sept.), 1–15. Google ScholarGoogle ScholarCross RefCross Ref
  22. Troy Kaighin Astarte. 2019. Formalising Meaning, a History of Programming Language Semantics. Ph.D. Dissertation. School of Computing, Newcastle University (June). Advisor: Cliff Jones.Google ScholarGoogle Scholar
  23. Sven Auhagen, Lars Bergstrom, Matthew Fluet, and John Reppy. 2011. Garbage Collection for Multicore NUMA Machines. In Proceedings of the ACM SIGPLAN Workshop on Memory Systems Performance and Correctness (MSPC 2011). Association for Computing Machinery, New York, NY, USA (June), 51–57. Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Brian Aydemir, Arthur Charguéraud, Benjamin C. Pierce, Randy Pollack, and Stephanie Weirich. 2008. Engineering Formal Metatheory. In Conference Record of the 35th Annual ACM Symposium on Principles of Programming Languages (POPL ’08) (San Francisco, CA, USA). Association for Computing Machinery, New York, NY, USA (Jan.), 3–15. Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. H. P. Barendregt. 1992. Lambda calculi with types. In Handbook of Logic in Computer Science (Volume 2). Oxford University Press, Oxford, UK, 117–309.Google ScholarGoogle Scholar
  26. D. W. Barron, J. N. Buxton, D. F. Hartley, E. Nixon, and C. Strachey. 1963. The Main Features of CPL. Comput. J. 6, 2 (Aug.), 134–143. Google ScholarGoogle ScholarCross RefCross Ref
  27. Marianne Baudinet and David MacQueen. 1985. Tree Pattern Matching for ML (extended abstract). Dec. 1985. http://smlfamily.org/history/Baudinet-DM-tree-pat-match-12-85.pdf Archived at Internet Archive: https://web.archive.org/web/ 20200316180154/http://sml-family.org/history/Baudinet-DM-tree-pat-match-12-85.pdf (16 March 2020 18:01:54)Google ScholarGoogle Scholar
  28. Mike Beaven and Ryan Stansifer. 1993. Explaining Type Errors in Polymorphic Languages. ACM Letters on Programming Languages and Systems 2, 1–4 (March–December), 17–30. Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Nick Benton and Andrew Kennedy. 1999. Monads, Effects and Transformations. Electronic Notes in Theoretical Computer Science 26, 3 – 20. Google ScholarGoogle ScholarCross RefCross Ref
  30. Nick Benton and Andrew Kennedy. 2001. Exceptional syntax. Journal of Functional Programming 11, 4, 295–410. Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Nick Benton, Andrew Kennedy, Sam Lindley, and Claudio Russo. 2005. Shrinking Reductions in SML.NET. In Implementation and Application of Functional Languages , Clemens Grelck, Frank Huch, Greg J. Michaelson, and Phil Trinder (Eds.). Springer-Verlag, New York, NY, USA, 142–159. Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Nick Benton, Andrew Kennedy, and George Russell. 1998. Compiling Standard ML to Java Bytecodes. In Proceedings of the Third ACM SIGPLAN International Conference on Functional Programming (ICFP ’98) (Baltimore, MD, USA). Association for Computing Machinery, New York, NY, USA (Sept.), 129–140. Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Nick Benton, Andrew Kennedy, and Claudio V. Russo. 2004. Adventures in interoperability: the SML.NET experience. In Proceedings of the 6th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming (PPDP ’04) (Verona, Italy). Association for Computing Machinery, New York, NY, USA (Aug.), 215–226. Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Karen L. Bernstein and Eugene W. Stark. 1995. Debugging Type Errors (Full Version). Technical Report. State University of New York and Stony Brook.Google ScholarGoogle Scholar
  35. Edoardo Biagioni, Robert Harper, Peter Lee, and Brian G. Milnes. 1994. Signatures for a Network Protocol Stack: A Systems Application of Standard ML. In Proceedings of the 1994 ACM Conference on Lisp and Functional Programming (LFP ’94) (Orlando, FL, USA). Association for Computing Machinery, New York, NY, USA (June), 55–64. Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Lars Birkedal, Nick Rothwell, Mads Tofte, and David N. Turner. 1993. The ML Kit (Version 1). Technical Report 93/14. Department of Computer Science, University of Copenhagen (March).Google ScholarGoogle Scholar
  37. Matthias Blume. 2001. No-Longer-Foreign: Teaching an ML compiler to speak C “natively.”. In First workshop on multilanguage infrastructure and interoperability (BABEL ’01) (Firenze, Italy) (Electronic Notes in Theoretical Computer Science), Vol. 59. Elsevier, New York, NY, USA (Sept.), 16. Issue 1. Google ScholarGoogle ScholarCross RefCross Ref
  38. Matthias Blume, Umut A. Acar, and Wonseok Chae. 2006. Extensible Programming with First-Class Cases. In Proceedings of the 11th ACM SIGPLAN International Conference on Functional Programming (ICFP ’06) (Portland, OR, USA). Association for Computing Machinery, New York, NY, USA (Sept.), 239–250. Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Matthias Blume, Umut A. Acar, and Wonseok Chae. 2008. Exception Handlers as Extensible Cases. In Proceedings of the 6th Asian Symposium on Programming Languages and Systems (APLAS ’08) (Bangalore, India) (Lecture Notes in Computer Science ), G. Ramalingam (Ed.), Vol. 5356. Springer-Verlag, New York, NY, USA (Dec.), 273–289. Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Matthias Blume and Andrew W. Appel. 1999. Hierarchical Modularity. ACM Transactions on Programming Languages and Systems 21, 4 (July), 813–847. Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Mark R. Brown and Greg Nelson. 1989. IO Streams: Abstract Types, Real Programs. Technical Report 53. Digital Systems Research Center, Palo Alto, CA, USA (Nov.).Google ScholarGoogle Scholar
  42. R. Burstall and J. Goguen. 1977. Putting theories together to make specifications. In Proceedings of the 5th International Joint Conference on Artificial Intelligence (II) (Cambridge, MA, USA), Raj Reddy (Ed.). AAAI Press, Palo Alto, CA, USA (Aug.), 1045–1058.Google ScholarGoogle Scholar
  43. Rod M. Burstall. 1977. Design Considerations for a Functional Programming Language. In The Software Revolution: Proceedings of the Infotech State of the Art Conference (Copenhagen, Denmark). Infotech and Pergamon Press, Oxford, UK (Oct.), 45–57.Google ScholarGoogle Scholar
  44. Rod M. Burstall, J. S. Collins, and R. J. Popplestone. 1977. Programming in POP-2. Edinburgh University Press, Edinburgh, UK.Google ScholarGoogle Scholar
  45. Rod M. Burstall and John Darlington. 1977. A Tranformation System for Developing Recursive Programs. Journal of the ACM 24, 1 (Jan.), 44–67. Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Rod M. Burstall and Peter Landin. 1969. Programs and their Proofs: an Algebraic Approach. In Machine Intelligence, B. Meltzer and D. Michie (Eds.). Vol. 4. Elsevier, New York, NY, USA, 17–43.Google ScholarGoogle Scholar
  47. Rod M. Burstall, David B. MacQueen, and Donald Sannella. 1980. HOPE: an experimental applicative language. In Conference Record of the 1980 ACM Conference on Lisp and Functional Programming (LFP ’80) . Association for Computing Machinery, New York, NY, USA (Aug.), 136–143. Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Rod M. Burstall and R. J. Popplestone. 1968. POP-2 reference manual. In Machine Intelligence 2, E. Dale and D. Mitchie (Eds.). Edinburgh University Press, Edinburgh, UK, 207–46.Google ScholarGoogle Scholar
  49. Georg Cantor. 1874. Über eine Eigenschaft des Inbegriffes aller reellen algebraischen Zahlen. Journal für die Reine und Angewandte Mathematik 77, 258–262.Google ScholarGoogle Scholar
  50. Luca Cardelli. 1980a. The ML Abstract Machine. Nov. 1980. http://sml-family.org/history/Cardelli-ML-abstract-machine1980.pdf Archived at Internet Archive: https://web.archive.org/web/20200316/http://sml-family.org/history/CardelliML-abstract-machine-1980.pdf (16 March 2020) Early description of the ML abstract machine (AM), precursor to the FAM.Google ScholarGoogle Scholar
  51. Luca Cardelli. 1980b. A Module Exchange Format. Dec. 1980. http://sml-family.org/history/Cardelli-MEX-1980_12.pdf Archived at Internet Archive: https://web.archive.org/web/20200316202334/http://sml-family.org/history/Cardelli-MEX-1980_12.pdf (16 March 2020 20:23:34) Description of a textual format for exporting internal ML data structures.Google ScholarGoogle Scholar
  52. Luca Cardelli. 1981. Differences Between VAX and DEC-10 ML. March 1981. 8 pages. http://sml-family.org/history/Cardellimlchanges_doc-1982_03.pdf Archived at Internet Archive: https://web.archive.org/web/20200317193405/http://smlfamily.org/history/Cardelli-mlchanges_doc-1982_03.pdf (17 March 2020 19:34:05)Google ScholarGoogle Scholar
  53. Luca Cardelli. 1982a. An Algebraic Approach to Hardware Description and Verification. Ph.D. Dissertation. University of Edinburgh (April).Google ScholarGoogle Scholar
  54. Luca Cardelli. 1982b. Edinburgh ML. March 1982. 2 pages. http://sml-family.org/history/Cardelli-Edinburgh-ML-README-1982_03.pdf Archived at Internet Archive: https://web.archive.org/web/20200317194022/http://sml-family.org/history/ Cardelli-Edinburgh-ML-README-1982_03.pdf (17 March 2020 19:40:22) README file for VAX ML (ML under VMS) distribution.Google ScholarGoogle Scholar
  55. Luca Cardelli. 1982c. Known VAX-ML System Locations. Polymorphism: The ML/LCF/Hope Newsletter I, 0 (Nov.), 4– 5. http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%200.pdf Archived at Internet Archive: https: //web.archive.org/web/20190225153220/http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%200.pdf (25 Feb. 2019 15:32:20)Google ScholarGoogle Scholar
  56. Luca Cardelli. 1982d. ML under VMS. Department of Computer Science, University of Edinburgh. http://sml-family.org/ history/Cardelli-ML-VMS-manual-1982.pdf Archived at Internet Archive: https://web.archive.org/web/20200317193823/ http://sml-family.org/history/Cardelli-ML-VMS-manual-1982.pdf (17 March 2020 19:38:23) Manual for ML under VMS.Google ScholarGoogle Scholar
  57. Luca Cardelli. 1983a. The Functional Abstract Machine. Polymorphism: The ML/LCF/Hope Newsletter I, 1 (Jan.), 16– 52. http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%201.pdf Archived at Internet Archive: https: //web.archive.org/web/20190307022704/http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%201.pdf (7 March 2019 02:27:04)Google ScholarGoogle Scholar
  58. Luca Cardelli. 1983b. ML under Unix. Bell Laboratories (Aug.). Manual for ML under Unix, Pose 2.Google ScholarGoogle Scholar
  59. Luca Cardelli. 1983c. Stream Input/Output. Polymorphism: The ML/LCF/Hope Newsletter I, 3 (Dec.), 9. http://lucacardelli. name/Papers/Polymorphism%20Vol%20I,%20No%203.pdf Archived at Internet Archive: https://web.archive.org/web/ 20190307145556/http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%203.pdf (7 March 2019 14:55:56)Google ScholarGoogle Scholar
  60. Luca Cardelli. 1984a. Compiling a Functional Language. In Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming (LFP ’84) (Austin, TX, USA). Association for Computing Machinery, New York, NY, USA (Aug.), 208–217. Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Luca Cardelli. 1984b. ML under Unix. Bell Laboratories (April). Manual for ML under Unix, Pose 4.Google ScholarGoogle Scholar
  62. Luca Cardelli and Xavier Leroy. 1990. Abstract Types and the Dot Notation. In Proceedings of the IFIP TC2 Working Conference on Programming Concepts and Methods . North Holland, Amsterdam, Netherlands (April), 479–504. also DEC SRC Tech Report 56.Google ScholarGoogle Scholar
  63. Felice Cardone, Jr. and Roger Hindley. 2009. Lambda-Calculus and Combinators in the 20th Century. In Logic from Russell to Church . Handbook of the History of Logic, Vol. 5. Elsevier, New York, NY, USA, 723–817. Also available as Swansea University Mathematics Department Research Report No. MRRS-05-06.Google ScholarGoogle Scholar
  64. Rudolf Carnap. 1929. Abriss der Logistik, mit besonderer berücksichtigung der relationstheorie und ihrer anwendungen. Springer-Verlag, Springer-Verlag. https://archive.org/details/RudolfCarnapAbrissDerLogistikGoogle ScholarGoogle Scholar
  65. Henry Cejtin, Matthew Fluet, Suresh Jagannathan, and Stephen Weeks. 2004. Formal Specification of the ML Basis System. . 8 pages. http://mlton.org/MLBasis.attachments/mlb-formal.pdf Archived at Internet Archive: https://web.archive.org/ web/20160909024016/http://mlton.org/MLBasis.attachments/mlb-formal.pdf (9 Sept. 2016 02:40:16)Google ScholarGoogle Scholar
  66. Henry Cejtin, Suresh Jagannathan, and Stephen Weeks. 2000. Flow-Directed Closure Conversion for Typed Languages. In Proceedings of the 9th European Symposium on Programming Languages and Systems (ESOP ’00) . Springer-Verlag, New York, NY, USA (March–April), 56–71. Google ScholarGoogle ScholarCross RefCross Ref
  67. Perry Cheng and Guy E. Blelloch. 2001. A Parallel, Real-Time Garbage Collector. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’01) (Snowbird, UT, USA). Association for Computing Machinery, New York, NY, USA (June), 125–136. Google ScholarGoogle ScholarDigital LibraryDigital Library
  68. Olaf Chitil. 2001. Compositional Explanation of Types and Algorithmic Debugging of Type Errors. In Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming (ICFP ’01) (Florence, Italy). Association for Computing Machinery, New York, NY, USA (Sept.), 193–204. Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. Charisee Chiw, Gordon Kindlmann, John Reppy, Lamont Samuels, and Nick Seltzer. 2012. Diderot: A Parallel DSL for Image Analysis and Visualization. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’12) (Beijing, China). Association for Computing Machinery, New York, NY, USA (June), 111–120. Google ScholarGoogle ScholarDigital LibraryDigital Library
  70. Adam Chlipala. 2015. Ur/Web: A Simple Model for Programming the Web. In Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (Mumbai, India). Association for Computing Machinery, New York, NY, USA (Jan.), 153–165. Google ScholarGoogle ScholarDigital LibraryDigital Library
  71. Venkatesh Choppella. 2002. Unification Source-Tracking with Application to Diagnosis of Type Inference. Ph.D. Dissertation. Department of Computer Science, University of Indiana, Bloomington, IN, USA (Aug.).Google ScholarGoogle Scholar
  72. Alonzo Church. 1940. A Formulation of the Simple Theory of Types. Journal of Symbolic Logic 5, 2 (June), 56–68.Google ScholarGoogle ScholarCross RefCross Ref
  73. Rance Cleaveland, Joachim Parrow, and Bernard Steffen. 1993. The Concurrency Workbench: A Semantics-based Tool for the Verification of Concurrent Systems. ACM Transactions on Programming Languages and Systems 15, 1 (Jan.), 36–72. Google ScholarGoogle ScholarDigital LibraryDigital Library
  74. P. M. Cohn. 1965. Universal Algebra. Harper Row, New York and London.Google ScholarGoogle Scholar
  75. Robert Cooper and Clifford D. Krumvieda. 1992. Distributed Programming with Asynchronous Ordered Channels in Distributed ML. In Proceedings of the 1992 ACM SIGPLAN Workshop on ML and its Applications. Department of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA (June), 134–148. Proceedings available as Technical Report CMU-CS-93-105.Google ScholarGoogle Scholar
  76. Thierry Coquand. 2018. Type Theory. In The Stanford Encyclopedia of Philosophy (Fall 2018 Edition), Edward N. Zalta (Ed.). The Metaphysics Research Lab, Center for the Study of Language and Information, Stanford University, Stanford, CA, USA (July). https://plato.stanford.edu/entries/type-theory/ Archived at Internet Archive: https://web.archive.org/web/ 20191211203338/https://plato.stanford.edu/entries/type-theory/ (11 Dec. 2019 20:33:38)Google ScholarGoogle Scholar
  77. Karl Crary and Robert Harper. 2009. Mechanization of Type Safety of Standard ML. Carnegie Mellon University (Aug.). Google ScholarGoogle ScholarCross RefCross Ref
  78. Karl Crary, Robert Harper, and Sidd Puri. 1999. What is a Recursive Module?. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’99) (Atlanta, GA, USA). Association for Computing Machinery, New York, NY, USA (May), 50–63. Google ScholarGoogle ScholarDigital LibraryDigital Library
  79. Pierre Crégut and David B. MacQueen. 1994. An Implementation of Higher-Order Functors. In Proceedings of the 1994 ACM SIGPLAN Workshop on ML and its Applications (Orlando, FL, USA). INRIA, Rocquencourt, France (June), 13–22.Google ScholarGoogle Scholar
  80. H. B. Curry. 1930. Grundlagen der kombinatorischen Logik. American Journal of Mathematics 52, 509–536, 789–834.Google ScholarGoogle ScholarCross RefCross Ref
  81. H. B. Curry. 1932. Some additions to the theory of combinators. American Journal of Mathematics 54, 551–558.Google ScholarGoogle ScholarCross RefCross Ref
  82. H. B. Curry. 1934. Functionality in Combinatory Logic. Proceedings of the National Academy of Sciences of the United States of America 20, 11 (Nov.), 584–590.Google ScholarGoogle Scholar
  83. H. B. Curry. 1969. Modified basic functionality in combinatory logic. Dialectica 23, 83–92.Google ScholarGoogle ScholarCross RefCross Ref
  84. H. B. Curry and R. Feys. 1958. Combinatory Logic, Volume I. North Holland, Amsterdam, Netherlands. 3rd edition 1974.Google ScholarGoogle Scholar
  85. Luis Damas. 1984. Type Assignment in Programming Languages. Ph.D. Dissertation. Department of Computer Science, University of Edinburgh, Edignburgh, UK.Google ScholarGoogle Scholar
  86. Luis Damas and Robin Milner. 1982. Principal type-schemes for functional programs. In Conference Record of the 9th Annual ACM Symposium on Principles of Programming Languages (POPL ’82) . Association for Computing Machinery, New York, NY, USA (Jan.), 207–212. Google ScholarGoogle ScholarDigital LibraryDigital Library
  87. Allyn Dimock, Ian Westmacott, Robert Muller, Franklyn Turbak, and J. B. Wells. 2001. Functioning without Closure: Type-Safe Customized Function Representations for Standard ML. In Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming (ICFP ’01) (Florence, Italy). Association for Computing Machinery, New York, NY, USA (Sept.), 14–25. Google ScholarGoogle ScholarDigital LibraryDigital Library
  88. Derek Dreyer. 2005. Understanding and Evolving the ML Module System. Ph.D. Dissertation. School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA (May).Google ScholarGoogle ScholarDigital LibraryDigital Library
  89. Derek Dreyer. 2007. A Type System for Recursive Modules. In Proceedings of the 12th ACM SIGPLAN International Conference on Functional Programming (ICFP ’07) . Association for Computing Machinery, New York, NY, USA (Oct.), 289–302. Google ScholarGoogle ScholarDigital LibraryDigital Library
  90. Derek Dreyer, Karl Crary, and Robert Harper. 2003. A Type System for Higher-Order Modules. In Conference Record of the 30th Annual ACM Symposium on Principles of Programming Languages (POPL ’03) . Association for Computing Machinery, New York, NY, USA (Jan.), 236–249. Google ScholarGoogle ScholarDigital LibraryDigital Library
  91. Derek Dreyer, Robert Harper, Manuel M. T. Chakravarty, and Gabrielle Keller. 2007. Modular type classes. In Conference Record of the 34th Annual ACM Symposium on Principles of Programming Languages (POPL ’07) . Association for Computing Machinery, New York, NY, USA (Jan.), 63–70. Google ScholarGoogle ScholarDigital LibraryDigital Library
  92. Derek Dreyer and Andreas Rossberg. 2008. Mixin’ up the ML Module System. In Proceedings of the 13th ACM SIGPLAN International Conference on Functional Programming (ICFP ’08) (Victoria, BC, Canada). Association for Computing Machinery, New York, NY, USA (Sept.), 307–320. Google ScholarGoogle ScholarDigital LibraryDigital Library
  93. Derek R. Dreyer, Robert Harper, and Karl Crary. 2001. Toward a Practical Type Theory for Recursive Modules. Technical Report CMU-CS-01-112. School of Computer Science, Carnegie Mellon University (March).Google ScholarGoogle Scholar
  94. Dominic Duggan and Frederick Bent. 1996. Explaining type inference. Science of Computer Programming 27, 1 (July), 37–83.Google ScholarGoogle ScholarDigital LibraryDigital Library
  95. Dominic Duggan and Constantinos Sourelis. 1996. Mixin Modules. In Proceedings of the 1996 ACM SIGPLAN International Conference on Functional Programming (ICFP ’96) (Philadelphia, PA, USA). Association for Computing Machinery, New York, NY, USA (May), 262–273. Google ScholarGoogle ScholarDigital LibraryDigital Library
  96. H. Ehrig, H.-J. Kreowski, J. Thatcher, E. Wagner, and J. Wright. 1980. Parameterized data types in algebraic specification languages. In Automata, Languages and Programming (ICALP ’80) (Noordwijkerhout, Netherlands) (Lecture Notes in Computer Science ), J. de Bakker and J. van Leeuwen (Eds.), Vol. 85. Springer-Verlag, New York, NY, USA (July), 157–168. Google ScholarGoogle ScholarCross RefCross Ref
  97. Peter Harry Eidorff, Fritz Henglein, Christian Mossin, Henning Niss, Morten Heine Sørensen, and Mads Tofte. 1999. AnnoDomini: From Type Theory to Year 2000 Conversion Tool. In Conference Record of the 26th Annual ACM Symposium on Principles of Programming Languages (POPL ’99) (San Antonio, TX, USA). Association for Computing Machinery, New York, NY, USA (Jan.), 1–14. Google ScholarGoogle ScholarDigital LibraryDigital Library
  98. Martin Elsman. 1998. Polymorphic Equality — No Tags Required. In Proceedings of the Second International Workshop on Types in Compilation (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA (March), 136–155. Google ScholarGoogle ScholarCross RefCross Ref
  99. Martin Elsman. 1999a. Program Modules, Separate Compilation, and Intermodule Optimisation. Ph.D. Dissertation. Department of Computer Science, University of Copenhagen (Jan.).Google ScholarGoogle Scholar
  100. Martin Elsman. 1999b. Static Interpretation of Modules. In Proceedings of the Fourth ACM SIGPLAN International Conference on Functional Programming (ICFP ’99) . Association for Computing Machinery, New York, NY, USA (Sept.), 208–219. Google ScholarGoogle ScholarDigital LibraryDigital Library
  101. Martin Elsman. 2011. SMLtoJs: Hosting a Standard ML Compiler in a Web Browser. In Proceedings of the 1st ACM SIGPLAN International Workshop on Programming Language and Systems Technologies for Internet Clients (PLASTIC ’11) (Portland, OR, USA). Association for Computing Machinery, New York, NY, USA, 39–48. Google ScholarGoogle ScholarDigital LibraryDigital Library
  102. Martin Elsman, Jeffrey S. Foster, and Alexander Aiken. 1999. Carillon — A System to Find Y2K Problems in C Programs. Computer Science Division, University of California, Berkeley (July). User’s Manual.Google ScholarGoogle Scholar
  103. Martin Elsman and Niels Hallenberg. 2003. Web Programming with SMLserver. In Fifth International Symposium on Practical Aspects of Declarative Languages (PADL’03) (New Orleans, LA, USA) (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA (Jan.), 74–91. Google ScholarGoogle ScholarCross RefCross Ref
  104. Arthur Evans, Jr. 1968a. PAL – a language designed for teaching programming linguistics. In Proceedings of the 1968 23rd ACM National Conference (ACM ’68) . Association for Computing Machinery, New York, NY, USA (Aug.), 395–403. Google ScholarGoogle ScholarDigital LibraryDigital Library
  105. Arthur Evans, Jr. 1968b. PAL – A reference manual and a primer. Technical Report. MIT Department of Electrical Engineering.Google ScholarGoogle Scholar
  106. Arthur Evans, Jr. 1970. PAL – Pedagigic Algorithmic Language. Technical Report. MIT Department of Electrical Engineering (Feb.).Google ScholarGoogle Scholar
  107. Matthias Felleisen and Daniel P. Friedman. 1998. The Little MLer. The MIT Press, Cambridge, MA, USA.Google ScholarGoogle Scholar
  108. Kathleen Fisher and John Reppy. 1999. The design of a class mechanism for Moby. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’99) (Atlanta, GA, USA). Association for Computing Machinery, New York, NY, USA (May), 37–49. Google ScholarGoogle ScholarDigital LibraryDigital Library
  109. Kathleen Fisher and John Reppy. 2002. Inhertance-based subtyping. Information and Computation 177, 1 (Aug.), 28–55. Google ScholarGoogle ScholarDigital LibraryDigital Library
  110. Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. 2010. Implicitly Threaded Parallelism in Manticore. Journal of Functional Programming 20, 5-6 (Nov.), 537–576. Google ScholarGoogle ScholarDigital LibraryDigital Library
  111. Gottlob Frege. 1879. Begriffsschrift. Verlag Louis Nebert, Halle, Germany. Also available in English as Begriffsschrift in van Heijenoort, 1967, pp. 1–82.Google ScholarGoogle Scholar
  112. Gottlob Frege. 1893. Grundgesetze der Arithmetik. Verlag Hermann Pohle, Jena, Germany.Google ScholarGoogle Scholar
  113. Emden R. Gansner and John H. Reppy. 1991. eXene. In Third International Workshop on Standard ML. Carnegie Mellon University, Pittsburgh, PA, USA (Sept.), 16. https://people.cs.uchicago.edu/~jhr/papers/1991/ml-exene.pdf Archived at Internet Archive: https://web.archive.org/web/20200328152609/https://people.cs.uchicago.edu/~jhr/papers/1991/mlexene.pdf (28 March 2020 15:26:09)Google ScholarGoogle Scholar
  114. Emden R. Gansner and John H. Reppy. 1993. A Multi-threaded Higher-order User Interface Toolkit. In User Interface Software, Bass and Dewan (Eds.) . Software Trends, Vol. 1. John Wiley & Sons, Inc., New York, NY, USA, 61–80.Google ScholarGoogle Scholar
  115. Emden R. Gansner and John H. Reppy (Eds.). 2004. The Standard ML Basis Library. Cambridge University Press, Cambridge, UK.Google ScholarGoogle Scholar
  116. Lal George and Andrew W. Appel. 1996. Iterated Register Coalescing. ACM Transactions on Programming Languages and Systems 18, 3 (May), 300–324. Google ScholarGoogle ScholarDigital LibraryDigital Library
  117. Lal George and Matthias Blume. 2003. Taming the IXP Network Processor. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’03) (San Diego, CA, USA). Association for Computing Machinery, New York, NY, USA (June), 26–37. Google ScholarGoogle ScholarDigital LibraryDigital Library
  118. Lal George, Florent Guillame, and John H. Reppy. 1994. A Portable and Optimizing Back End for the SML/NJ Compiler. In Proceedings of the 5th International Conference on Compiler Construction (CC ’94) . Springer-Verlag, New York, NY, USA (April), 83–97. Google ScholarGoogle ScholarCross RefCross Ref
  119. Stephen Gilmore. 1997. Programming in Standard ML ’97: A Tutorial Introduction. Technical Report ECS-LFCS-97-364. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (Sept.). Also available online at http://homepages.inf.ed.ac.uk/stg/NOTES .Google ScholarGoogle Scholar
  120. Jean-Yves Girard. 1972. Interprétation fonctionelle et élimination des coupures de l’arithmétique d’ordre supérieur. Ph.D. Dissertation. Université Paris VII. Thése d’état.Google ScholarGoogle Scholar
  121. Benjamin Goldberg. 1991. Tag-free Garbage Collection for Strongly Typed Programming Languages. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’91) (Toronto, Canada). Association for Computing Machinery, New York, NY, USA (June), 165–176. Google ScholarGoogle ScholarDigital LibraryDigital Library
  122. Benjamin Goldberg and Michael Gloger. 1992. Polymorphic Type Reconstruction for Garbage Collection Without Tags. In Conference record of the 1992 ACM Conference on Lisp and Functional Programming (LFP ’92) (San Francisco, CA, USA). Association for Computing Machinery, New York, NY, USA (June), 53–65. Google ScholarGoogle ScholarDigital LibraryDigital Library
  123. M. Gordon, R. Milner, L. Morris, M. Newey, and C. Wadsworth. 1978a. A Metalanguage for Interactive Proof in LCF. In Conference Record of the 5th Annual ACM Symposium on Principles of Programming Languages (POPL ’78) . Association for Computing Machinery, New York, NY, USA (Jan.), 119–130. Google ScholarGoogle ScholarDigital LibraryDigital Library
  124. Michael J. Gordon, Arthur J. Milner, and Christopher P. Wadsworth. 1979. Edinburgh LCF. Lecture Notes in Computer Science, Vol. 78. Springer-Verlag, New York, NY, USA. Google ScholarGoogle ScholarCross RefCross Ref
  125. Michael J. C. Gordon. 1980. Locations as first class objects in ML. . http://sml-family.org/history/Gordon-ML-refs-1980.pdf Archived at Internet Archive: https://web.archive.org/web/20200317194215/http://sml-family.org/history/Gordon-ML-refs-1980.pdf (17 March 2020 19:42:15) Note to Luis Damas proposing a research topic.Google ScholarGoogle Scholar
  126. M. J. C. Gordon, R. Milner, L. Morris, M. C. Newey, and C. P. Wadsworth. 1978b. A metalanguage for interactive proof in LCF. In Conference Record of the 5th Annual ACM Symposium on Principles of Programming Languages (POPL ’78). Association for Computing Machinery, New York, NY, USA (Jan.), 119–130. Google ScholarGoogle ScholarDigital LibraryDigital Library
  127. Timoth Griffin and Howard Trickey. 1994. Integrity Maintenance in a Telecommunications Switch. Bulletin of the Technical Committee on Data Engineering 17, 2 (June), 43–46.Google ScholarGoogle Scholar
  128. Christian Haack and J. B. Wells. 2004. Type Error Slicing in Implicitly Typed Higher-Order Languages. Science of Computer Programming 50, 1–3 (March), 189–224. Google ScholarGoogle ScholarDigital LibraryDigital Library
  129. Jurriaan Hage and Bastiaan Heeren. 2006. Heuristics for type error discovery and recovery. In 18th International Symposium on the Implementation and Application of Functional Languages (IFL ’06) (Budapest, Hungary) (Lecture Notes in Computer Science ). Springer-Verlag, New York, NY, USA, 199–216. Google ScholarGoogle ScholarCross RefCross Ref
  130. Nick Haines. 1991. Compiling ML to a Strongly-typed System. In Third International Workshop on Standard ML. School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA (Sept.), 11.Google ScholarGoogle Scholar
  131. Niels Hallenberg, Martin Elsman, and Mads Tofte. 2002. Combining Region Inference and Garbage Collection. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’02) (Berlin, Germany). Association for Computing Machinery, New York, NY, USA (June), 141–152. Google ScholarGoogle ScholarDigital LibraryDigital Library
  132. Kevin Hammond. 1988. Parallel SML: a Functional Language and its Implementation in Dactl. Pitman, London, UK.Google ScholarGoogle Scholar
  133. Wilfred J. Hansen. 1992. Subsequence References: First-class Values for Substrings. ACM Transactions on Programming Languages and Systems 14, 4 (Oct.), 471–489. Google ScholarGoogle ScholarDigital LibraryDigital Library
  134. D. R. Hanson. 1990. Fast Allocation and Deallocation of Memory Based on Object Lifetimes. Software – Practice and Experience 20, 1 (Jan.), 5–12. Google ScholarGoogle ScholarDigital LibraryDigital Library
  135. Robert Harper. 1985. Report on the Standard ML Meeting, Edinburgh, May 23–25, 1985 (DRAFT). . 10 pages. http: //sml-family.org/history/Harper-SML-meeting-1985_05.pdf Archived at Internet Archive: https://web.archive.org/web/ 20200316201215/http://sml-family.org/history/Harper-SML-meeting-1985_05.pdf (16 March 2020 20:12:15)Google ScholarGoogle Scholar
  136. Robert Harper. 1986. Standard ML Input/Output. In Standard ML. Number ECS-LFCS-86-2 in LFCS Report Series. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (March). This paper is dated June 10, 1985.Google ScholarGoogle Scholar
  137. Robert Harper. 1994. A Simplified Account of Polymorphic References. Inform. Process. Lett. 51, 201–206. Google ScholarGoogle ScholarDigital LibraryDigital Library
  138. Robert Harper. 2011. Programming in Standard ML. Carnegie Mellon University (Feb.). http://www.cs.cmu.edu/~rwh/isml/ book.pdf Archived at Internet Archive: https://web.archive.org/web/20191212212327/http://www.cs.cmu.edu/~rwh/isml/ book.pdf (12 Dec. 2019 21:23:27)Google ScholarGoogle Scholar
  139. Robert Harper. 2016. Practical Foundations for Programming Languages (2 ed.). Cambridge University Press, Cambridge, UK.Google ScholarGoogle Scholar
  140. Robert Harper, Furio Honsell, and Gordon Plotkin. 1993a. A Framework for Defining Logics. Journal of the ACM 40, 1 (Jan.), 143–184. Google ScholarGoogle ScholarDigital LibraryDigital Library
  141. Robert Harper and Peter Lee. 1994. Advanced Languages for System Software — The Fox Project in 1994. Technical Report CMU-CS-94-104. School of Computer Science, Carnegie Mellon University, Pittsburgh, PA (Jan.).Google ScholarGoogle Scholar
  142. Robert Harper, Peter Lee, Frank Pfenning, and Gene Rollins. 1994. A Compilation Manager for SML/NJ. In Proceedings of the 1994 ACM SIGPLAN Workshop on ML and its Applications (Orlando, FL, USA) (INRIA Technical Report). INRIA, Rocquencourt, France (June), 136–147.Google ScholarGoogle Scholar
  143. Robert Harper and Mark Lillibridge. 1994. A type-theoretic approach to higher-order modules with sharing. In Conference Record of the 21st Annual ACM Symposium on Principles of Programming Languages (POPL ’94) . Association for Computing Machinery, New York, NY, USA (Jan.), 123–137. Google ScholarGoogle ScholarDigital LibraryDigital Library
  144. Robert Harper, David MacQueen, and Robin Milner. 1986. Standard ML. Technical Report ECS-LFCS-86-2. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (March).Google ScholarGoogle Scholar
  145. Robert Harper, David B. MacQueen, and Bruce F. Duba. 1993b. Typing first-class continuations in ML. Journal of Functional Programming 3 (Oct.), 465–484. 10.1017/S095679680000085XGoogle ScholarGoogle ScholarCross RefCross Ref
  146. Robert Harper, Robin Milner, and Mads Tofte. 1987a. The Semantics of Standard ML, Version 1. Technical Report ECS-LFCS-87-36. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (Aug.).Google ScholarGoogle Scholar
  147. R. Harper, R. Milner, and M. Tofte. 1987b. A type discipline for program modules. In Proceedings of the International Joint Conference on Theory and Practice of Software Development (TAPSOFT ’87) (Lecture Notes in Computer Science), H. Ehrig, R. Kowalski, G. Levi, and U. Montanari (Eds.). Springer-Verlag, New York, NY, USA (March), 308–319. Google ScholarGoogle ScholarCross RefCross Ref
  148. Robert Harper, Robin Milner, and Mads Tofte. 1988. The Definition of Standard ML, Version 2. Technical Report ECS-LFCS-88-62. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (Aug.).Google ScholarGoogle Scholar
  149. Robert Harper, Robin Milner, and Mads Tofte. 1989. The Definition of Standard ML, Version 3. Technical Report ECS-LFCS-89-81. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (May).Google ScholarGoogle Scholar
  150. Robert Harper and John C. Mitchell. 1993. On the type structure of Standard ML. ACM Transactions on Programming Languages and Systems 15, 2, 211–252. Google ScholarGoogle ScholarDigital LibraryDigital Library
  151. Robert Harper, John C. Mitchell, and Eugenio Moggi. 1990. Higher-order modules and the phase distinction. In Conference Record of the 17th Annual ACM Symposium on Principles of Programming Languages (POPL ’90) . Association for Computing Machinery, New York, NY, USA (Jan.), 341–354. Google ScholarGoogle ScholarDigital LibraryDigital Library
  152. Robert Harper and Christopher Stone. 2000. A type-theoretic interpretation of Standard ML. In Proof, Language and Interaction: Essays in Honour of Robin Milner , Gordon Plotkin, Colin Sterling, and Mads Tofte (Eds.). The MIT Press, Cambridge, MA, USA, 341–388.Google ScholarGoogle ScholarDigital LibraryDigital Library
  153. D. Hilbert and W. Ackermann. 1928. Grundzüge der Theoretischen Logik. Springer-Verlag, Berlin, Germany.Google ScholarGoogle Scholar
  154. J. Roger Hindley. 1969. The principal type scheme of an object in combinatory logic. Trans. Amer. Math. Soc. 146 (Dec.), 29–60. Google ScholarGoogle ScholarCross RefCross Ref
  155. J. Roger Hindley. 1997. Basic Simple Type Theory. Cambridge Tracts in Theoretical Computer Science, Vol. 42. Cambridge University Press, Cambridge, UK.Google ScholarGoogle ScholarDigital LibraryDigital Library
  156. J. Roger Hindley. 2008. M. H. Newman’s Typability Algorithm for Lambda-calculus. Journal of Logic and Computation 18, 2, 229–238. Google ScholarGoogle ScholarDigital LibraryDigital Library
  157. Tom Hirschowitz and Xavier Leroy. 2005. Mixin modules in a call-by-value setting. ACM Transactions on Programming Languages and Systems 27, 5 (Sept.), 857–881. Google ScholarGoogle ScholarDigital LibraryDigital Library
  158. HOL 2019. HOL: Interactive Theorem Prover. HOL (Aug.). https://hol-theorem-prover.org Archived at Internet Archive: https://web.archive.org/web/20190925051532/https://hol-theorem-prover.org/ (25 Sept. 2019 05:15:32)Google ScholarGoogle Scholar
  159. S. Holmström. 1983. PFL: A functional language for parallel programming. In Declarative Programming Workshop. University College, London, UK (April), 114–139. Extended version published as Report 7, Programming Methodology Group, Chalmers University, September 1983.Google ScholarGoogle Scholar
  160. IEEE. 1985. IEEE Standard for Binary Floating-Point Arithmetic. Technical Report IEEE Std 754-1985. IEEE (Aug.).Google ScholarGoogle Scholar
  161. IEEE. 1993. Portable Operating System Interface — Part 1: System Application Program Interface (API) [C Language]. Technical Report IEEE Std 1003.1. IEEE.Google ScholarGoogle Scholar
  162. The University of Cambridge 2019. Isabelle. The University of Cambridge (June). https://www.cl.cam.ac.uk/research/hvg/ Isabelle/index.html Archived at Internet Archive: https://web.archive.org/web/20190927025407/https://www.cl.cam.ac. uk/research/hvg/Isabelle/index.html (27 Sept. 2019 02:54:07)Google ScholarGoogle Scholar
  163. Kathleen Jensen and Niklaus Wirth. 1978. Pascal User Manual and Report (2nd ed.). Springer-Verlag, New York, NY, USA.Google ScholarGoogle Scholar
  164. Gregory F. Johnson and Janet A. Walz. 1986. A maximum-flow approach to anomaly isolation in unification-based incremental type inference. In Conference Record of the 13th Annual ACM Symposium on Principles of Programming Languages (POPL ’86) . Association for Computing Machinery, New York, NY, USA (Jan.), 44–57. Google ScholarGoogle ScholarDigital LibraryDigital Library
  165. Gilles Kahn. 1987. Natural Semantics. In Symposium on Theoretical Aspects of Computer Science (STACS ’87) (Lecture Notes in Computer Science ), Vol. 247. Springer-Verlag, New York, NY, USA, 22–39. Google ScholarGoogle ScholarCross RefCross Ref
  166. Stefan Kahrs. 1993. Mistakes and ambiguities in the Definition of Standard ML. Technical Report ECS-LFCS-93-257. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (April).Google ScholarGoogle Scholar
  167. Stefan Kahrs and Donald Sannella. 1998. Reflections on the Design of a Specification language. In Proceedings of the First International Conference on Fundamental Approaches to Software Engineering (FASE ’98) (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA, 154–170. Google ScholarGoogle ScholarCross RefCross Ref
  168. Stefan Kahrs, Don Sannella, and Andrzej Tarlecki. 1994. The Definition of Extended ML. Technical Report ECS-LFCS-94-300. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK.Google ScholarGoogle Scholar
  169. Stefan Kahrs, Donald Sannella, and Andrzej Tarlecki. 1997. The Definition of Extended ML: A Gentle Introduction. Theoretical Computer Science 173, 2, 445–484. Google ScholarGoogle ScholarDigital LibraryDigital Library
  170. Fairouz Kamareddine, Twan Laan, and Rob Nederpelt. 2004. A Modern Perspective on Type Theory: From its Origins until Today . Applied Logic Series, Vol. 29. Kluwer Academic Publishers, Dordrecht/Boston/London.Google ScholarGoogle Scholar
  171. Andrew Kennedy. 2007. Compiling with Continuations, Continued. In Proceedings of the 12th ACM SIGPLAN International Conference on Functional Programming (ICFP ’07) (Freiburg, Germany). Association for Computing Machinery, New York, NY, USA (Oct.), 177–190. Google ScholarGoogle ScholarDigital LibraryDigital Library
  172. Andrew Kennedy and Don Syme. 2001. Design and Implementation of Generics for the .NET Common Language Runtime. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’01) (Snowbird, UT, USA). Association for Computing Machinery, New York, NY, USA (June), 1–12. Google ScholarGoogle ScholarDigital LibraryDigital Library
  173. Andrew J. Kennedy. 1996. Programming languages and dimensions. Ph.D. Dissertation. University of Cambridge, Computer Science Department, Cambridge, UK (April). Also available as Technical Report CL-TR-391.Google ScholarGoogle Scholar
  174. Clifford D. Krumvieda. 1993. Distributed ML: Abstractions for Efficient and Fault-Tolerant Programming. Ph.D. Dissertation. Department of Computer Science, Cornell University, Ithaca, NY, USA (Aug.). Available as Technical Report TR 93-1376.Google ScholarGoogle Scholar
  175. George Kuan. 2010. A True Higher-Order Module System. Ph.D. Dissertation. Department of Computer Science, University of Chicago, Chicago, IL, USA.Google ScholarGoogle Scholar
  176. George Kuan and David MacQueen. 2007. Efficient ML Type Inference Using Ranked Type Variables. In Proceedings of the 2007 ACM SIGPLAN Workshop on ML (ML ’07) . Association for Computing Machinery, New York, NY, USA (Oct.), 3–14. Google ScholarGoogle ScholarDigital LibraryDigital Library
  177. George Kuan and David MacQueen. 2010. Engineering Higher-Order Modules in SML/NJ. In 21st International Workshop on the Implementation and Application of Functional Languages (IFL ’09) (South Orange, NJ, USA) (Lecture Notes in Computer Science ), M. T. Morazán and S. B. Scholz (Eds.), Vol. 6041. Springer-Verlag, New York, NY, USA (Sept.), 218–235. Google ScholarGoogle ScholarCross RefCross Ref
  178. Peter J. Landin. 1964. The mechanical evaluation of expressions. Comput. J. 6, 4, 308–320. Google ScholarGoogle ScholarCross RefCross Ref
  179. Peter J. Landin. 1965a. A correspondence between ALGOL 60 and Church’s lambda-notation: Part I. Commun. ACM 8, 2 (Feb.), 89–101. Google ScholarGoogle ScholarDigital LibraryDigital Library
  180. Peter J. Landin. 1965b. A correspondence between ALGOL 60 and Church’s lambda-notation: Part II. Commun. ACM 8, 3 (March), 158–165. Google ScholarGoogle ScholarDigital LibraryDigital Library
  181. Peter J. Landin. 1966a. A Lambda-Calculus Approach. In Advances in Programming and Non-Numerical Computation, L. Fox (Ed.). Pergamon Press, Oxford, UK, Chapter 5, 97–141. Google ScholarGoogle ScholarCross RefCross Ref
  182. Peter J. Landin. 1966b. The next 700 programming languages. Commun. ACM 9, 3, 157–66. Google ScholarGoogle ScholarDigital LibraryDigital Library
  183. Peter J. Landin. 1998. A Generalization of Jumps and Labels. Higher-order and Symbolic Computation 11, 2 (Dec.), 117–123. Google ScholarGoogle ScholarDigital LibraryDigital Library
  184. Daniel K. Lee, Karl Crary, and Robert Harper. 2007. Towards a mechanized metatheory of Standard ML. In Conference Record of the 34th Annual ACM Symposium on Principles of Programming Languages (POPL ’07) (Nice, France). Association for Computing Machinery, New York, NY, USA (Jan.), 173–184. Google ScholarGoogle ScholarDigital LibraryDigital Library
  185. Oukseh Lee and Kwangkeun Yi. 1998. Proofs about a folklore let-polymorphic type inference algorithm. ACM Transactions on Programming Languages and Systems 20, 4 (July), 707–723. Google ScholarGoogle ScholarDigital LibraryDigital Library
  186. Daan Leijen and Erik Meijer. 1999. Domain Specific Embedded Compilers. In Proceedings of the 2nd Conference on DomainSpecific Languages (DSL ’99) (Austin, TX, USA). The USENIX Association, Berkeley, CA, USA (Oct.), 109–122. Google ScholarGoogle ScholarDigital LibraryDigital Library
  187. Benjamin Lerner, Matthew Flower, , Dan Grossman, and Craig Chambers. 2007. Searching for Type-Error Messages. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’07) (San Diego, CA, USA). Association for Computing Machinery, New York, NY, USA (June), 425–434. Google ScholarGoogle ScholarDigital LibraryDigital Library
  188. Xavier Leroy. 1993. Polymorphism by name for references and continuations. In Conference Record of the 20th Annual ACM Symposium on Principles of Programming Languages (POPL ’93) . Association for Computing Machinery, New York, NY, USA (Jan.), 220–231. Google ScholarGoogle ScholarDigital LibraryDigital Library
  189. Xavier Leroy. 1994. Manifest types, modules, and separate compilation. In Conference Record of the 21st Annual ACM Symposium on Principles of Programming Languages (POPL ’94) . Association for Computing Machinery, New York, NY, USA (Jan.), 109–122. Google ScholarGoogle ScholarDigital LibraryDigital Library
  190. Xavier Leroy. 1995. Applicative functors and fully transparent higher-order modules. In Conference Record of the 22nd Annual ACM Symposium on Principles of Programming Languages (POPL ’95) . Association for Computing Machinery, New York, NY, USA (Jan.), 142–153. Google ScholarGoogle ScholarDigital LibraryDigital Library
  191. Xavier Leroy. 1996. A syntactic theory of type generativity and sharing. Journal of Functional Programming 6, 5, 667–698. Google ScholarGoogle ScholarCross RefCross Ref
  192. Allen Leung and Lal George. 1999. Static Single Assignment Form for Machine Code. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’99) (Atlanta, GA, USA). Association for Computing Machinery, New York, NY, USA (May), 204–214. Google ScholarGoogle ScholarDigital LibraryDigital Library
  193. Mark Lillibridge. 1997. Translucent Sums: A Foundation for Higher-Order Module Systems. Ph.D. Dissertation. School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA (May).Google ScholarGoogle Scholar
  194. Mark Lillibridge and Robert Harper. 1991. ML with callcc is unsound. . Posting to Types mailing list. July 1991. https://www. seas.upenn.edu/~sweirich/types/archive/1991/msg00034.html Archived at Internet Archive: https://web.archive.org/ web/20150116061224/https://www.seas.upenn.edu/~sweirich/types/archive/1991/msg00034.html (16 Feb. 2015 06:12:24) Example of ML type unsoundness caused by first-class continuations.Google ScholarGoogle Scholar
  195. C. H. Lindsey. 1996. A History of ALGOL 68. Association for Computing Machinery, New York, NY, USA, 27–96. Google ScholarGoogle ScholarDigital LibraryDigital Library
  196. Barbara Liskov, Russell Atkinson, Toby Bloom, Eliot Moss, J. Craig Schaffert, Robert Scheifler, and Alan Snyder. 1981. CLU Reference Manual . Lecture Notes in Computer Science, Vol. 114. Springer-Verlag, New York, NY, USA. Google ScholarGoogle ScholarCross RefCross Ref
  197. Barbara Liskov, Alan Snyder, Russell Atkinson, and J. Craig Schaffert. 1977. Abstraction Mechanisms in CLU. CACM 20, 8 (Aug.), 564–576. Google ScholarGoogle ScholarDigital LibraryDigital Library
  198. P. Lucas, P. Lauer, and H. Stigleitner. 1968. Method and notation for the formal definition of programming languages. Technical Report TR 25.037. IBM Laboratory Vienna, Vienna, Austria (June).Google ScholarGoogle Scholar
  199. Zhaohui Luo and Randy Pollack. 1992. LEGO Proof Development System: User’s Manual. Technical Report ECS-LFCS-92-211. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK.Google ScholarGoogle Scholar
  200. David MacQueen. 1983a. Modified Damas Algorithm for Typechecking with References. March 1983. 6 pages. http://smlfamily.org/history/MacQueen-typechecking-refs-1983_03_22.pdf Archived at Internet Archive: https://web.archive. org/web/20200316202127/http://sml-family.org/history/MacQueen-typechecking-refs-1983_03_22.pdf (16 March 2020 20:21:27) Manuscript note dated 1983.03.22.Google ScholarGoogle Scholar
  201. David MacQueen. 2002. Should ML be Object-Oriented? Formal Aspects of Computing 13, 214–232. Google ScholarGoogle ScholarDigital LibraryDigital Library
  202. David MacQueen. 2010. A simple and effective method for assigning blame for type errors. In Proceedings of the 2010 ACM SIGPLAN Workshop on ML (ML ’10) (Baltimore, MD, USA). Association for Computing Machinery, New York, NY, USA (Sept.), 2.Google ScholarGoogle Scholar
  203. David MacQueen and Robin Milner. 1985. Record of the Standard ML Meeting, Edinburgh, 6–8 June 1984. Polymorphism: The ML/LCF/Hope Newsletter II, 1 (Jan.), 16. http://lucacardelli.name/Papers/Polymorphism%20Vol%20II,%20No% 201.pdf Archived at Internet Archive: https://web.archive.org/web/20190225113300/http://lucacardelli.name/Papers/ Polymorphism%20Vol%20II,%20No%201.pdf (25 Feb. 2019 11:33:00)Google ScholarGoogle Scholar
  204. David MacQueen and Mads Tofte. 1994. A semantics for higher order functors. In Proceedings of the 5th European Symposium on Programming (ESOP ’94) (Edinburg, UK) (Lecture Notes in Computer Science), Vol. 788. Springer-Verlag, New York, NY, USA (April), 409–423. Google ScholarGoogle ScholarCross RefCross Ref
  205. David B. MacQueen. 1981. Structure and parameterization in a typed functional language. In The Symposium on Functional Languages and Computer Architecture (Aspenäs, Sweden). Laboratory for Programming Methodology, Department of Computer Science, University of Göteborg, Göteborg, Sweden (June), 524–538.Google ScholarGoogle Scholar
  206. David B. MacQueen. 1983b. Modules for Standard ML. Polymorphism: The ML/LCF/Hope Newsletter I, 3 (Dec.), 31. http: //lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%203.pdf Archived at Internet Archive: https://web.archive. org/web/20190307145556/http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%203.pdf (7 March 2019 14:55:56)Google ScholarGoogle Scholar
  207. David B. MacQueen. 1984. Modules for Standard ML. In Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming (LFP ’84) (Austin, TX, USA). Association for Computing Machinery, New York, NY, USA (Aug.), 198–207. Google ScholarGoogle ScholarDigital LibraryDigital Library
  208. David B. MacQueen. 1985a. Dependent Types and Modular Structure. June 1985. http://sml-family.org/history/MacQueenMarstrand-talk-1985.pdf Archived at Internet Archive: https://web.archive.org/web/20200316201128/http://sml-family. org/history/MacQueen-Marstrand-talk-1985.pdf (16 March 2020 20:11:28) Talk at Workshop on Specification and Derivation of Programs.Google ScholarGoogle Scholar
  209. David B. MacQueen. 1985b. Modules for Standard ML. Polymorphism: The ML/LCF/Hope Newsletter II, 2 (Oct.), 37. http://lucacardelli.name/Papers/Polymorphism%20Vol%20II,%20No%202.pdf Archived at Internet Archive: https://web. archive.org/web/20190308005136/http://lucacardelli.name/Papers/Polymorphism%20Vol%20II,%20No%202.pdf (8 March 2019 00:51:36) Also in Edinburgh LFCS Tech Report ECS-LFCS-86-2.Google ScholarGoogle Scholar
  210. David B. MacQueen. 1986. Using dependent types to express modular structure. In Conference Record of the 13th Annual ACM Symposium on Principles of Programming Languages (POPL ’86) . Association for Computing Machinery, New York, NY, USA (Jan.), 277–286. Google ScholarGoogle ScholarDigital LibraryDigital Library
  211. David B. MacQueen. 1994. Reflections on Standard ML. In Functional Programming, Concurrency, Simulation and Automated Reasoning , Peter E. Lauer (Ed.). Lecture Notes in Computer Science, Vol. 693. Springer-Verlag, New York, NY, USA, 32–46. Google ScholarGoogle ScholarCross RefCross Ref
  212. David B. MacQueen. 2015. Notes on Newman’s “Stratified systems of logic”. May 2015. http://sml-family.org/history/ MacQueen-Newman-talk-WG28-2015.pdf Archived at Internet Archive: https://web.archive.org/web/20200317195338/ http://sml-family.org/history/MacQueen-Newman-talk-WG28-2015.pdf (17 March 2020 19:53:38) Slides for talk at IFIP Working Group 2.8 meeting, Kefalonia.Google ScholarGoogle Scholar
  213. B. J. Mailloux, J. E. L. Peck, C. H. A. Koster, and A. van Wijngaarden. 1969. Report on the Algorithmic Language ALGOL 68. Springer-Verlag, New York, NY, USA, 80–218. Google ScholarGoogle ScholarCross RefCross Ref
  214. Luc Maranget. 2008. Compiling Pattern Matching to Good Decision Trees. In Proceedings of the 2008 ACM SIGPLAN Workshop on ML (ML ’08) . Association for Computing Machinery, New York, NY, USA (Sept.), 35–46. Google ScholarGoogle ScholarDigital LibraryDigital Library
  215. Per Martin-Löf. 1982. Constructive Mathematics and Computer Programming. In Logic, Methodology and Philosophy of Science, VI, 1979 . North Holland, Amsterdam, Netherlands, 153–175.Google ScholarGoogle Scholar
  216. Per Martin-Löf. 1984. Intuitionistic Type Theory. Studies in Proof Theory, Vol. 1. Bibliopolis, Napoli, Italy.Google ScholarGoogle Scholar
  217. David C. J. Matthews. 1988. An Overview of the Poly Programming Language. In Data Types and Persistence, Malcolm P. Atkinson, Peter Buneman, and Ronald Morrison (Eds.). Springer-Verlag, New York, NY, USA, 43–50.Google ScholarGoogle Scholar
  218. David C. J. Matthews. 1989. Papers on Poly/ML. Technical Report 161. University of Cambridge Computer Laboratory (Feb.).Google ScholarGoogle Scholar
  219. Bruce McAdam. 2002. Repairing Type Errors in Functional Programs. Ph.D. Dissertation. Laboratory for Foundations of Computer Science, Division of Informatics, University of Edinburgh. LFCS Tech Report ECS-LFCS-02-427.Google ScholarGoogle Scholar
  220. Bruce J. McAdam. 1998. On the Unification of Substitutions in Type-Inference. Technical Report ECS-LFCS-98-384. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (March).Google ScholarGoogle Scholar
  221. John McCarthy. 1960. Recursive functions of symbolic expressions and their computation by machine, Part I. Commun. ACM 3, 4 (April), 184–195.Google ScholarGoogle ScholarDigital LibraryDigital Library
  222. John McCarthy. 1963. A basis for a mathematical theory of computation. In Computer Programming and Formal Systems, P. Braffort and D. Hirshberg (Eds.). North Holland, Amsterdam, Netherlands.Google ScholarGoogle Scholar
  223. John McCarthy. 1966. A formal description of a subset of ALGOL. In Foraml Language Description Languages for Computer Programming . North Holland, Amsterdam, Netherlands, 1–12.Google ScholarGoogle Scholar
  224. Robert Milne. 1974. The Formal Semantics of Computer Languages and their Implementations. Ph.D. Dissertation. Oxford University.Google ScholarGoogle Scholar
  225. Robin Milner. 1972. Implementation and applications of Scott’s Logic for Computable Functions. In Proceedings of the ACM Conference on Proving Assertions about Programs . Association for Computing Machinery, New York, NY, USA (Jan.), 1–6. Google ScholarGoogle ScholarDigital LibraryDigital Library
  226. Robin Milner. 1978. A theory of type polymorphism in programming. J. Comput. System Sci. 17, 3 (Dec.), 348–375. Google ScholarGoogle ScholarCross RefCross Ref
  227. Robin Milner. 1980. A Calculus of Communicating Systems. Number 92 in Lecture Notes in Computer Science. Springer-Verlag, New York, NY, USA. Google ScholarGoogle ScholarCross RefCross Ref
  228. Robin Milner. 1983a. Changes to proposal for Standard ML. May 1983. 5 pages. http://sml-family.org/history/SML-changes4-83.pdf Archived at Internet Archive: https://web.archive.org/web/20170708224109/http://sml-family.org/history/SML-changes-4-83.pdf (8 July 2017 22:41:09)Google ScholarGoogle Scholar
  229. Robin Milner. 1983b. Discussion with Rod Burstall about precompilation. June 1983. 1 pages. http://sml-family.org/ history/Milner-Burstall-precompilation-1983_06_30.pdf Archived at Internet Archive: https://web.archive.org/web/ 20200317195454/http://sml-family.org/history/Milner-Burstall-precompilation-1983_06_30.pdf (17 March 2020 19:54:54) Manuscript note, dated 1983.6.30.Google ScholarGoogle Scholar
  230. Robin Milner. 1983c. A Proposal for Standard ML (second draft). June 1983. 50 pages. http://sml-family.org/history/SML-proposal-6-83.pdf Archived at Internet Archive: https://web.archive.org/web/20170705163956/http://sml-family.org/ history/SML-proposal-6-83.pdf (5 July 2017 16:39:56)Google ScholarGoogle Scholar
  231. Robin Milner. 1983d. A Proposal for Standard ML (TENTATIVE). April 1983. 25 pages. http://sml-family.org/history/SML-proposal-4-83.pdf Archived at Internet Archive: https://web.archive.org/web/20170708224143/http://sml-family.org/ history/SML-proposal-4-83.pdf (8 Aug. 2017 22:41:43)Google ScholarGoogle Scholar
  232. Robin Milner. 1984a. ML Meeting Skeleton Timetable. June 1984. 1 pages. http://sml-family.org/history/SML-meeting-84-schedule.pdf Archived at Internet Archive: https://web.archive.org/web/20200317195928/http://sml-family.org/history/ SML-meeting-84-schedule.pdf (17 March 2020 19:59:28) proposed timetable for June 84 design meeting.Google ScholarGoogle Scholar
  233. Robin Milner. 1984b. A proposal for Standard ML. In Conference Record of the 1984 ACM Symposium on Lisp and Functional Programming (LFP ’84) (Austin, TX, USA). Association for Computing Machinery, New York, NY, USA (Aug.), 184–197. Google ScholarGoogle ScholarDigital LibraryDigital Library
  234. Robin Milner. 1984c. A simplified syntax for instances and module definitions, with a proposal for treating sharing specifications. May 1984. 5 pages. http://sml-family.org/history/Milner-module-notation-1984_05_23.pdf Archived at Internet Archive: https://web.archive.org/web/20200317195607/http://sml-family.org/history/Milner-module-notation1984_05_23.pdf (17 March 2020 19:56:07) Manuscript note dated 23/5/84, prepared for the June 1984 meeting.Google ScholarGoogle Scholar
  235. Robin Milner. 1985a. The Dynamic Operational Semantics of Standard ML (3rd Draft). April 1985. 18 pages. http: //sml-family.org/history/Milner-dyn-semantics-1985_04.pdf Archived at Internet Archive: https://web.archive.org/web/ 20200317200028/http://sml-family.org/history/Milner-dyn-semantics-1985_04.pdf (17 March 2020 20:00:28)Google ScholarGoogle Scholar
  236. Robin Milner. 1985b. Schedule for Standard ML meeting 23–25 May 1985. May 1985. 1 pages. http://sml-family.org/history/ SML-meeting-schedule-1985_05.pdf Archived at Internet Archive: https://web.archive.org/web/20200317200130/http: //sml-family.org/history/SML-meeting-schedule-1985_05.pdf (17 March 2020 20:01:30) proposed timetable for May 1985 design meeting.Google ScholarGoogle Scholar
  237. Robin Milner. 1985c. Webs. Sept. 1985. 14 pages. http://sml-family.org/history/Milner-webs-1985_09_01.pdf Archived at Internet Archive: https://web.archive.org/web/20200317001840/http://sml-family.org/history/Milner-webs-1985_09_01. pdf (17 March 2020 00:18:40) “A way of approaching the static semantics of sharing in modules”.Google ScholarGoogle Scholar
  238. Robin Milner. 1986. The Standard ML Core Language (Revised). In Standard ML. Number ECS-LFCS-86-2 in LFCS Report Series. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (March).Google ScholarGoogle Scholar
  239. Robin Milner. 1987. Changes to the Standard ML Core language. Technical Report ECS-LFCS-87-33. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (Aug.).Google ScholarGoogle Scholar
  240. Robin Milner and Mads Tofte. 1991. Commentary on Standard ML. The MIT Press, Cambridge, MA, USA.Google ScholarGoogle Scholar
  241. Robin Milner, Mads Tofte, and Robert Harper. 1990. The Definition of Standard ML. The MIT Press, Cambridge, MA, USA.Google ScholarGoogle ScholarDigital LibraryDigital Library
  242. Robin Milner, Mads Tofte, Robert Harper, and David MacQueen. 1997. The Definition of Standard ML (Revised). The MIT Press, Cambridge, MA, USA.Google ScholarGoogle ScholarDigital LibraryDigital Library
  243. John Mitchell and Ramesh Viswanathan. 1996. Standard ML-NJ Weak Polymorphism and Imperative Constructs. Information and Computation 127, 102–116. Google ScholarGoogle ScholarCross RefCross Ref
  244. John C. Mitchell and Robert Harper. 1988. The Essence of ML. In Conference Record of the 15th Annual ACM Symposium on Principles of Programming Languages (POPL ’88) . Association for Computing Machinery, New York, NY, USA (Jan.), 28–46. Google ScholarGoogle ScholarDigital LibraryDigital Library
  245. John C. Mitchell and Gordon D. Plotkin. 1988. Abstract types have existential types. ACM Transactions on Programming Languages and Systems 10, 3, 470–502. Google ScholarGoogle ScholarDigital LibraryDigital Library
  246. Kevin Mitchell. 1983. ML Progress Report. Sept. 1983. 8 pages. http://sml-family.org/history/KMitchell-Edinburgh-SML-progress-report-1983_09_13.pdf Archived at Internet Archive: https://web.archive.org/web/20200317001939/http://smlfamily.org/history/KMitchell-Edinburgh-SML-progress-report-1983_09_13.pdf (17 March 2020 00:19:39) manuscript report to Rod Burstall.Google ScholarGoogle Scholar
  247. Kevin Mitchell and Robin Milner. 1985. Proposal for I/O in Standard ML. In ML Workshop ’85. The Standard ML Group, Edinburgh, UK (May), 7. This proposal was originally dated February 1985, but was presented at the ML Workshop in May 1985.Google ScholarGoogle Scholar
  248. Kevin Mitchell and Alan Mycroft. 1985. The Edinburgh Standard ML Compiler. Jan. 1985. 15 pages. http://smlfamily.org/history/KMitchell-Mycroft-Edinburgh%20Standard%20ML%20Compiler-1985_01.pdf Archived at Internet Archive: https://web.archive.org/web/20200317200700/http://sml-family.org/history/KMitchell-Mycroft-Edinburgh% 20Standard%20ML%20Compiler-1985_01.pdf (17 March 2020 20:07:00) draft note on the Edinburgh SML compiler.Google ScholarGoogle Scholar
  249. ML2000 Working Group. 1999. Principles and a preliminary design for ML2000. March 1999. http://flint.cs.yale.edu/flint/ publications/ml2000.pdf Archived at Internet Archive: https://web.archive.org/web/20170829123149/http://flint.cs.yale. edu/flint/publications/ml2000.pdf (29 Aug. 2017 12:31:49)Google ScholarGoogle Scholar
  250. University of Copenhagen 2019. Try MLKit! The Standard ML Compiler and Toolkit. University of Copenhagen (July). http: //elsman.com/mlkit Archived at Internet Archive: https://web.archive.org/web/20181128041300/http://elsman.com/mlkit/ (28 Nov. 2018 04:13:00)Google ScholarGoogle Scholar
  251. MLton 2020. MLton. MLton (Jan.). http://mlton.org Archived at Internet Archive: https://web.archive.org/web/ 20200201103035/http://www.mlton.org/ (1 Feb. 2020 10:30:35)Google ScholarGoogle Scholar
  252. MLton 2014. MLton History. MLton (Jan.). http://mlton.org/History Archived at Internet Archive: https://web.archive.org/ web/20180212200726/http://mlton.org/History (12 Feb. 2018 20:07:26)Google ScholarGoogle Scholar
  253. Eugenio Moggi. 1991. A category-theoretic account of program modules. Mathematical Structures in Computer Science 1, 1, 103–139. Google ScholarGoogle ScholarCross RefCross Ref
  254. Greg Morrisett. 1995. Compiling with Types. Ph.D. Dissertation. School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA (Dec.). Published as Technical Report CMU-CS-95-226.Google ScholarGoogle Scholar
  255. Greg Morrisett, David Walker, Karl Crary, and Neal Glew. 1998. From System F to typed assembly language. In Conference Record of the 25th Annual ACM Symposium on Principles of Programming Languages (POPL ’98) (San Diego, CA, USA). Association for Computing Machinery, New York, NY, USA, 85–97. Google ScholarGoogle ScholarDigital LibraryDigital Library
  256. J. Gregory Morrisett and Andrew Tolmach. 1993. Procs and Locks: A Portable Multiprocessing Platform for Standard ML of New Jersey. In Proceedings of the 4th ACM SIGPLAN Symposium on Principles & Practice of Parallel Programming. Association for Computing Machinery, New York, NY, USA (April), 198–207. Google ScholarGoogle ScholarDigital LibraryDigital Library
  257. Moscaow ML 2014. Moscow ML. Moscaow ML (Aug.). https://mosml.org Archived at Internet Archive: https://web.archive. org/web/20190514124005/https://mosml.org/ (14 May 2019 12:40:05)Google ScholarGoogle Scholar
  258. M. H. A. Newman. 1943. Stratified systems of logic. Proceedings of the Cambridge Philosophical Society 39, 69–83.Google ScholarGoogle ScholarCross RefCross Ref
  259. Flemming Nielson (Ed.). 1997. ML with Concurrency: Design, Analysis, Implementation, and Application. Springer-Verlag, New York, NY, USA.Google ScholarGoogle Scholar
  260. INRIA 2019. A History of OCaml. INRIA. https://ocaml.org/learn/history.html Archived at Internet Archive: https: //web.archive.org/web/20200118031918/https://ocaml.org/learn/history.html (18 Jan. 2020 03:19:18) Accessed 2019:11:06.Google ScholarGoogle Scholar
  261. Atsushi Ohori. 1992. A Compilation Method for ML-Style Polymorphic Record Calculi. In Conference Record of the 19th Annual ACM Symposium on Principles of Programming Languages (POPL ’92) (Albuquerque, NM, USA). Association for Computing Machinery, New York, NY, USA (Jan.), 154–165. Google ScholarGoogle ScholarDigital LibraryDigital Library
  262. Atsushi Ohori. 1995. A Polymorphic Record Calculus and Its Compilation. ACM Transactions on Programming Languages and Systems 17, 6 (Nov.), 844–895. Google ScholarGoogle ScholarDigital LibraryDigital Library
  263. Atsushi Ohori, Katsuhiro Ueno, Kazunori Hoshi, Shinji Nozaki, Takashi Sato, Tasuku Makabe, and Yuki Ito. 2014. SML# in Industry: A Practical ERP System Development. In Proceedings of the 20th ACM SIGPLAN International Conference on Functonal Programming (ICFP ’14) (Gothenburg, Sweden). Association for Computing Machinery, New York, NY, USA (Sept.), 167–173. Google ScholarGoogle ScholarDigital LibraryDigital Library
  264. L.C. Paulson. 1996. ML for the Working Programmer (2nd ed.). Cambridge University Press, Cambridge, UK.Google ScholarGoogle Scholar
  265. Zvonimir Pavlinovic, Tim King, and Thomas Wies. 2015. Practical SMT-based type error localization. In Proceedings of the 20th ACM SIGPLAN International Conference on Functonal Programming (ICFP ’15) (Vancouver, BC, Canada). Association for Computing Machinery, New York, NY, USA (Sept.), 412–423. Google ScholarGoogle ScholarDigital LibraryDigital Library
  266. G. Peano. 1889. Arithmetices Principia, Nova Methodo Exposita. Fratelli Bocca, Torino, Italy.Google ScholarGoogle Scholar
  267. Leaf Petersen, Perry Chang, Robert Harper, and Chris Stone. 2000. Implementing the TILT Internal Language. Technical Report CMU-CS-00-180. School of Computer Science, Carnegie Mellon University (Dec.).Google ScholarGoogle Scholar
  268. Leaf Eames Petersen. 2005. Certifying Compilation for Standard ML in a Type Analysis Framework. Ph.D. Dissertation. Carnegie Mellon University, Pittsburgh PA (May). Published as technical report CMU-CS-05-135.Google ScholarGoogle Scholar
  269. Mikael Pettersson. 1992. A term pattern-match compiler inspired by finite automata theory. In Proceedings of the 4th International Conference on Compiler Construction (CC ’92) (Lecture Notes in Computer Science), Vol. 641. Springer-Verlag, New York, NY, USA, 258–270. Google ScholarGoogle ScholarCross RefCross Ref
  270. Frank Pfenning and Carsten Schürmann. 1999. System Description: Twelf — A Meta-Logical Framework for Deductive Systems. In Proceedings of the 16th International Conference on Automated Deduction (CADE-16) (Lecture Notes in Artificial Intelligence ), H. Ganzinger (Ed.). Springer-Verlag, New York, NY, USA, 202–206. Google ScholarGoogle ScholarCross RefCross Ref
  271. Benjamine C. Pierce. 2002. Types and Programming Languages. The MIT Press, Cambridge, MA, USA.Google ScholarGoogle ScholarDigital LibraryDigital Library
  272. Gordon D. Plotkin. 1981. A structural approach to operational semantics. Technical Report. Computer Science Department, Aarhus University.Google ScholarGoogle Scholar
  273. Gordon D. Plotkin. 2004. The Origins of Structural Operational Semantics. Jounal of Logic and Algebraic Programming 60-61, 3–15. Google ScholarGoogle ScholarCross RefCross Ref
  274. School of Computer Science, The University of Birmingham 2019. Information about Poplog and Pop-11. School of Computer Science, The University of Birmingham (Dec.). https://www.cs.bham.ac.uk/research/projects/poplog/poplog.info.html Archived at Internet Archive: https://web.archive.org/web/20200201105451/https://www.cs.bham.ac.uk/research/projects/ poplog/poplog.info.html (1 Feb. 2020 10:54:51)Google ScholarGoogle Scholar
  275. R. J. Popplestone. 1968a. The design philosophy of POP-2. In Machine Intelligence 3, D. Mitchie (Ed.). Edinburgh University Press, Edinburgh, UK, 393–402.Google ScholarGoogle Scholar
  276. R. J. Popplestone. 1968b. POP-1: an on-line language. In Machine Intelligence 2, E. Dale and D. Mitchie (Eds.). Edinburgh University Press, Edinburgh, UK, 185–94.Google ScholarGoogle Scholar
  277. François Pottier. 2011. [TYPES] System F omega with (equi-)recursive types. June 2011. 1 pages. http://sml-family.org/history/ Pottier-System-F-omega-with-(equi-)recursive-types-2011.pdf Archived at Internet Archive: https://web.archive.org/ web/20200317200824/http://sml-family.org/history/Pottier-System-F-omega-with-(equi-)recursive-types-2011.pdf (17 March 2020 20:08:24) message to the Types mailing list.Google ScholarGoogle Scholar
  278. Francçois Pottier and Didier Rémy. 2005. The Essence of ML Type Inference. In Advanced Topics in Types and Programming Languages , Benjamin Pierce (Ed.). The MIT Press, Cambridge, MA, USA, 387–489.Google ScholarGoogle Scholar
  279. Riccardo Pucella. 2001. Notes on Programming Standard ML of New Jersey. Department of Computer Science, Cornell University (Jan.). http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf Archived at Internet Archive: https://web.archive.org/web/20180827154235/http://www.cs.cornell.edu/riccardo/prog-smlnj/notes-011001.pdf (27 Aug. 2018 15:42:35)Google ScholarGoogle Scholar
  280. F. P. Ramsey. 1926. The foundations of mathematics. Proceedings of the London Mathematical Society, 2nd Series 25, 338–384.Google ScholarGoogle ScholarCross RefCross Ref
  281. Norman Ramsey. 1990. Concurrent programming in ML. Technical Report CS-TR-262-90. Department of Computer Science, Princeton University, Princeton, NJ, USA (April).Google ScholarGoogle Scholar
  282. Norman Ramsey, Kathleen Fisher, and Paul Govereau. 2005. An Expressive Language of Signatures. In Proceedings of the 10th ACM SIGPLAN International Conference on Functional Programming (ICFP ’05) (Tallinn, Estonia). Association for Computing Machinery, New York, NY, USA (Sept.), 27–40. Google ScholarGoogle ScholarDigital LibraryDigital Library
  283. Didier Rémy. 1992. Extension of ML type system with a sorted equation theory on types. Technical Report RR-1766. INRIA, Rocquencourt, France (Oct.).Google ScholarGoogle Scholar
  284. John Reppy, Claudio V. Russo, and Yingqi Xiao. 2009. Parallel Concurrent ML. In Proceedings of the 14th ACM SIGPLAN International Conference on Functional Programming (ICFP ’09) (Edinburgh, Scotland, UK). Association for Computing Machinery, New York, NY, USA (August–September), 257–268. Google ScholarGoogle ScholarDigital LibraryDigital Library
  285. John H. Reppy. 1988. Synchronous operations as first-class values. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’88) . Association for Computing Machinery, New York, NY, USA (June), 250–259. Google ScholarGoogle ScholarDigital LibraryDigital Library
  286. John H. Reppy. 1989. First-class synchronous operations in Standard ML. Technical Report TR 89-1068. Department of Computer Science, Cornell University, Ithaca, NY (Dec.).Google ScholarGoogle Scholar
  287. John H. Reppy. 1991. CML: A higher-order concurrent language. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’91) . Association for Computing Machinery, New York, NY, USA (June), 293–305. Google ScholarGoogle ScholarDigital LibraryDigital Library
  288. John H. Reppy. 1993. A High-performance Garbage Collector for Standard ML. Technical Memo BL011261-940329-12TM. AT&T Bell Laboratories (Dec.). https://people.cs.uchicago.edu/~jhr/papers/1993/tm-gc.pdf Archived at Internet Archive: https://web.archive.org/web/20200328124914/https://people.cs.uchicago.edu/~jhr/papers/1993/tm-gc.pdf (28 March 2020 12:49:14)Google ScholarGoogle Scholar
  289. John H. Reppy. 1996. A safe interface to sockets (Draft). May 1996. 10 pages. http://sml-family.org/history/safe-sockets.pdf Archived at Internet Archive: https://web.archive.org/web/20200313180819/http://sml-family.org/history/safe-sockets. pdf (13 March 2020 18:08:19)Google ScholarGoogle Scholar
  290. John H. Reppy. 1999. Concurrent Programming in ML. Cambridge University Press, Cambridge, UK.Google ScholarGoogle ScholarDigital LibraryDigital Library
  291. John H. Reppy and Jon G. Riecke. 1996. Simple Objects for Standard ML. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’96) (Philadelphia, PA, USA). Association for Computing Machinery, New York, NY, USA (May), 171–180. Google ScholarGoogle ScholarDigital LibraryDigital Library
  292. John C. Reynolds. 1970. GEDANKEN – A Simple Typeless Language Based on the Principle of Completeness and the Reference Concept. Commun. ACM 13, 5 (May), 308–319. Google ScholarGoogle ScholarDigital LibraryDigital Library
  293. John C. Reynolds. 1972. Definitional Interpreters for Higher-order Programming Languages. In Proceedings of the ACM Annual Conference - Volume 2 (Boston, MA, USA). Association for Computing Machinery, New York, NY, USA (Aug.), 717–740. Google ScholarGoogle ScholarDigital LibraryDigital Library
  294. John C. Reynolds. 1974. Towards a theory of type structure. In Colloquium on Programming (Paris, France) (Lecture Notes in Computer Science ), Vol. 19. Springer-Verlag, New York, NY, USA (April), 408–423. Google ScholarGoogle ScholarCross RefCross Ref
  295. John A. Robinson. 1965. A machine-oriented logic based on the resolution principle. Journal of the ACM 12, 1 (Jan.), 23–41. Google ScholarGoogle ScholarDigital LibraryDigital Library
  296. Andreas Rossberg. 2008. HaMLet S — To Become or Not Become Successor ML. Max Planck Institute for Software Systems (April). https://people.mpi-sws.org/~rossberg/hamlet/hamlet-succ-1.3.1S5.pdf Archived at Internet Archive: https: //web.archive.org/web/20170330175359/https://people.mpi-sws.org/~rossberg/hamlet/hamlet-succ-1.3.1S5.pdf (30 March 2017 17:53:59)Google ScholarGoogle Scholar
  297. Andreas Rossberg. 2013a. Defects in the Revised Definition of Standard ML. Technical Report. Universität des Saarlandes.Google ScholarGoogle Scholar
  298. Andreas Rossberg. 2013b. HaMLet — To Be or Not To Be Standard ML (Version 2.0.0). Max Planck Institute for Software Systems (Oct.). https://people.mpi-sws.org/~rossberg/hamlet/hamlet-2.0.0.pdf Archived at Internet Archive: https: //web.archive.org/web/20200328172628/https://people.mpi-sws.org/~rossberg/hamlet/hamlet-2.0.0.pdf (28 March 2020 17:26:28)Google ScholarGoogle Scholar
  299. Andreas Rossberg. 2015. 1ML – Core and Modules United (F-ing First-Class Modules). In Proceedings of the 20th ACM SIGPLAN International Conference on Functonal Programming (ICFP ’15) . Association for Computing Machinery, New York, NY, USA (Sept.), 35–47. Google ScholarGoogle ScholarDigital LibraryDigital Library
  300. Andreas Rossberg. 2018. 1ML – Core and Modules United. Journal of Functional Programming 28, e22 (Dec.), 60. Google ScholarGoogle ScholarCross RefCross Ref
  301. Andreas Rossberg, Didier Le Botlan, Guido Tack, Thorsten Brunklaus, and Gert Smolka. 2006. Alice Through the Looking Glass . Trends in Functional Programming, Vol. 5. Intellect Books, Bristol, UK, Munich, Germany (Feb.), 79–96.Google ScholarGoogle Scholar
  302. Andreas Rossberg and Derek Dreyer. 2013. Mixin’ Up the ML Module System. ACM Transactions on Programming Languages and Systems 35, 1 (April), Article 2, 84 pages. Google ScholarGoogle ScholarDigital LibraryDigital Library
  303. Andreas Rossberg, Claudio Russo, and Derek Dreyer. 2015. F-ing modules. Journal of Functional Programming 24, 5, 529–607. Google ScholarGoogle ScholarCross RefCross Ref
  304. Bertrand Russell. 1967. Letter to Frege. In From Frege to Gödel, Jean van Heijenoort (Ed.). Harvard University Press, Cambridge, MA, USA, 124–125.Google ScholarGoogle Scholar
  305. Bertrand Russell and Alfred North Whitehead. 1910,1912,1913. Principia Mathematica (3 Volumes). Cambridge University Press, Cambridge, UK.Google ScholarGoogle Scholar
  306. Claudio Russo. 1999a. The Definition of Non-Standard ML (Syntax and Static Semantics). July 1999. http://smlfamily.org/history/Russo-defn-nonStandard-ML-2014.pdf Archived at Internet Archive: https://web.archive.org/web/ 20200317055151/http://sml-family.org/history/Russo-defn-nonStandard-ML-2014.pdf (17 March 2020 05:51:51) Unpublished manuscript.Google ScholarGoogle Scholar
  307. Claudio Russo. 1999b. Non-dependent Types for Standard ML Modules. In Proceedings of the International Conference on Principles and Practice of Declarative Programming (PPDP ’99) (Paris, France) (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA (September–October), 80–97. Google ScholarGoogle ScholarCross RefCross Ref
  308. Claudio V. Russo. 1998. Types For Modules. Ph.D. Dissertation. University of Edinburgh. Edinburgh LFCS Technical Report ECS-LFCS-98-389.Google ScholarGoogle Scholar
  309. Claudio V. Russo. 2001. Recursive Structures for Standard ML. In Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming (ICFP ’01) (Florence, Italy). Association for Computing Machinery, New York, NY, USA (Sept.), 50–61. Google ScholarGoogle ScholarDigital LibraryDigital Library
  310. Mark Ryan and Martin Sadler. 1992. Valuation Systems and Consequent Relations. In Background: Mathematical Structures. Handbook of Logic in Computer Science, Vol. 1. Clarendon Press, Oxford, UK, 1–78.Google ScholarGoogle Scholar
  311. Bratin Saha and Zhong Shao. 1998. Optimal Type Lifting. In Types in Compilation Workshop (Kyoto, Japan) (Lecture Notes in Computer Science ). Springer-Verlag, New York, NY, USA (March), 156–177. Google ScholarGoogle ScholarCross RefCross Ref
  312. Nobuo Saito. 1982. ML System on Vax Unix. March 1982. 3 pages. http://sml-family.org/history/Saito-Mlsys-README-1982_03.pdf Archived at Internet Archive: https://web.archive.org/web/20200317201310/http://sml-family.org/history/ Saito-Mlsys-README-1982_03.pdf (17 March 2020 20:13:10) README for Saito’s Unix port of VAX ML.Google ScholarGoogle Scholar
  313. Donald Sannella. 1985. A Denotational Semantics for ML Modules. Nov. 1985. http://sml-family.org/history/Sannellamodule-sematics-1985_11.pdf Archived at Internet Archive: https://web.archive.org/web/20200317055334/http://smlfamily.org/history/Sannella-module-sematics-1985_11.pdf (17 March 2020 05:53:34) Draft of 25 November 1985.Google ScholarGoogle Scholar
  314. Donald Sannella and Andrzej Tarlecki. 1985. Program Specification and Development in Standard ML. In Conference Record of the 12th Annual ACM Symposium on Principles of Programming Languages (POPL ’85) . Association for Computing Machinery, New York, NY, USA (Jan.), 67–77. Google ScholarGoogle ScholarDigital LibraryDigital Library
  315. Thomas Schilling. 2011. Constraint-Free Type Error Slicing. In Trends in Functional Programming (TFP ’11) (Lecture Notes in Computer Science ). Springer-Verlag, New York, NY, USA, 1–16. Google ScholarGoogle ScholarDigital LibraryDigital Library
  316. Moses Schönfinkel. 1924. Über die Bausteine der mathematischen Logik. Math. Ann. 92, 305–316. Also available in English as "On the building blocks of mathematical logic" in van Heijenoort, 1967, pp 355–366.Google ScholarGoogle ScholarCross RefCross Ref
  317. Carsten Schürmann. 2009. The Twelf Proof Assistant. In Theorem Proving in Higher Order Logics (TPHOLs ’09) (Munich, Germany) (Lecture Notes in Computer Science), Stefan Berghofer, Tobias Nipkow, Christian Urban, and Makarius Wenzel (Eds.). Springer-Verlag, New York, NY, USA, 79–83. Google ScholarGoogle ScholarDigital LibraryDigital Library
  318. Dana S. Scott and C. Strachey. 1971. Towards a mathematical semantics for computer languages. In Proceedings of the Symposium on Computers and Automata (Brooklyn, NY, USA). Polytechnic Press, New York, NY, USA, 19–46.Google ScholarGoogle Scholar
  319. Jonathan P. Seldin. 2009. The Logic of Church and Curry. In Logic from Russell to Church. Handbook of the History of Logic, Vol. 5. Elsevier, New York, NY, USA, 819–873.Google ScholarGoogle Scholar
  320. Peter Sestoft. 1996. ML pattern match compilation and partial evaluation. In Partial Evaluation (Lecture Notes in Computer Science ), Vol. 1110. Springer-Verlag, New York, NY, USA, 446–464. Google ScholarGoogle ScholarCross RefCross Ref
  321. Zhong Shao. 1997. An Overview of the FLINT/ML Compiler. In Proceedings of the 1997 ACM SIGPLAN Workshop on Types in Compilation (TIC’97) (Amsterdam, The Netherlands). Association for Computing Machinery, New York, NY, USA (June), 10.Google ScholarGoogle Scholar
  322. Zhong Shao and Andrew W. Appel. 1995. A Type-based Compiler for Standard ML. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’95) (La Jolla, CA, USA). Association for Computing Machinery, New York, NY, USA (June), 116–129. Google ScholarGoogle ScholarDigital LibraryDigital Library
  323. Zhong Shao and Andrew W. Appel. 2000. Efficient and Safe-for-space Closure Conversion. ACM Transactions on Programming Languages and Systems 22, 1 (Jan.), 129–161. Google ScholarGoogle ScholarDigital LibraryDigital Library
  324. Zhong Shao, Christopher League, and Stefan Monnier. 1998. Implementing typed intermediate languages. In Proceedings of the Third ACM SIGPLAN International Conference on Functional Programming (ICFP ’98) . Association for Computing Machinery, New York, NY, USA (Sept.), 313–323. Google ScholarGoogle ScholarDigital LibraryDigital Library
  325. Joanna Sharrad, Olaf Chitil, and Meng Wang. 2018. Delta Debugging Type Errors with a Blackbox Compiler. In 30th Symposium on Implementation and Application of Functional Languages (IFL ’18) (Lowell, MA, USA). Association for Computing Machinery, New York, NY, USA (Sept.), 13–24. Google ScholarGoogle ScholarDigital LibraryDigital Library
  326. Anthony L. Shipman. 2002. Unix System Programming with Standard ML. . 482 pages. http://mlton.org/References. attachments/Shipman02.pdf Archived at Internet Archive: https://web.archive.org/web/20200225113813/http://mlton. org/References.attachments/Shipman02.pdf (25 Feb. 2020 11:38:13)Google ScholarGoogle Scholar
  327. K. C. Sivaramakrishnan, Lukasz Ziarek, and Suresh Jagannathan. 2014. MultiMLton: A multicore-aware runtime for Standard ML. Journal of Functional Programming 24, 6 (June), 613–674. Google ScholarGoogle ScholarCross RefCross Ref
  328. Marvin Solomon. 1978. Type definitions with parameters (Extended Abstract). In Conference Record of the 5th Annual ACM Symposium on Principles of Programming Languages (POPL ’78) . Association for Computing Machinery, New York, NY, USA (Jan.), 31–38. Google ScholarGoogle ScholarDigital LibraryDigital Library
  329. T. B. Steel, Jr. (Ed.). 1966. Formal Language Description Languages for Computer Programming. North Holland, Amsterdam, Netherlands.Google ScholarGoogle Scholar
  330. Christopher Stone and Robert Harper. 2000. Deciding Type Equivalence in a Language with Singleton Kinds. In Proceedings of the 27th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’00) (Boston, MA, USA). Association for Computing Machinery, New York, NY, USA, 214–227. Google ScholarGoogle ScholarDigital LibraryDigital Library
  331. Christopher Allan Stone. 2000. Singleton Kinds and Singleton Types. Ph.D. Dissertation. Carnegie Mellon University, Pittsburgh, PA, USA (Aug.). CMU-CS-00-153.Google ScholarGoogle Scholar
  332. Christopher A. Stone and Robert Harper. 2006. Extensional Equivalence and Singleton Types. ACM Transactions on Computational Logic 7, 4 (Oct.), 676–722. Google ScholarGoogle ScholarDigital LibraryDigital Library
  333. C. Strachey. 1966. CPL Reference Manual. July 1966. 128 pages. http://www.ancientgeek.org.uk/CPL/CPL_Working_Papers. pdf Archived at Internet Archive: https://web.archive.org/web/20190813125728/http://www.ancientgeek.org.uk/CPL/ CPL_Working_Papers.pdf (13 Aug. 2019 12:57:28) Privately circulated. Programming Research Unit, Oxford University.Google ScholarGoogle Scholar
  334. Christopher Strachey. 1967. Fundamental Concepts in Programming Languages. In Lecture Notes from the International Summer School in Computer Science (Copenhagen, Denmark). 38. Google ScholarGoogle ScholarDigital LibraryDigital Library
  335. Peter J. Stuckey, Martin Sulzmann, and Jeremy Wazny. 2004. Improving Type Error Diagnosis. In Proceedings of the 2004 ACM SIGPLAN workshop on Haskell (Haskell ’04) . Association for Computing Machinery, New York, NY, USA (Sept.), 80–91. Google ScholarGoogle ScholarDigital LibraryDigital Library
  336. David Swasey, Tom Murphy VII, Karl Crary, and Robert Harper. 2006a. A Separate Compilation Extension to Standard ML. In Proceedings of the 2006 ACM SIGPLAN Workshop on ML (ML ’06) (Portland, OR, USA), Andrew Kennedy and Fran cois Pottier (Eds.). Association for Computing Machinery, New York, NY, USA (Sept.), 32–42. Google ScholarGoogle ScholarDigital LibraryDigital Library
  337. David Swasey, Tom Murphy VII, Karl Crary, and Robert Harper. 2006b. A Separate Compilation Extension to Standard ML (Revised and Expanded) . Technical Report CMU–CS–06–133. Carnegie Mellon University School of Computer Science, Pittsburgh, PA, USA (September).Google ScholarGoogle Scholar
  338. Walid Taha and Tim Sheard. 2000. MetaML and Multi-Stage Programming with Explicit Annotations. Theoretical Computer Science 248, 1–2 (Oct.), 211–242. Google ScholarGoogle ScholarDigital LibraryDigital Library
  339. David Tarditi. 1996. Design and Implementation of Code Optimizations for a Type Directed Compiler for Standard ML. Ph.D. Dissertation. School of Computer Science, Carnegie Mellon University, Pittsburgh, PA, USA (Dec.). Published as Technical Report CMU-CS-97-108.Google ScholarGoogle Scholar
  340. D. Tarditi, G. Morrisett, P. Cheng, C. Stone, R. Harper, and P. Lee. 1996. TIL: A Type-directed Optimizing Compiler for ML. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’96) (Philadelphia, PA, USA). Association for Computing Machinery, New York, NY, USA (May), 181–192. Google ScholarGoogle ScholarDigital LibraryDigital Library
  341. David Tarditi, Greg Morrisett, Perry Cheng, Chris Stone, Robert Harper, and Peter Lee. 2004. TIL: A Type-Directed, Optimizing Compiler for ML. SIGPLAN Notices 39, 4 (April), 554–567. Google ScholarGoogle ScholarDigital LibraryDigital Library
  342. Robert D. Tennent. 1977. Language design methods based on semantic principles. Acta Informatica 8, 97–112. Google ScholarGoogle ScholarCross RefCross Ref
  343. J. W. Thatcher, E. G. Wagner, and J. B. Wright. 1982. Data type specification: parameterization and the power of specification techniques. ACM Transactions on Programming Languages and Systems 4, 4 (Oct.), 711–732. Google ScholarGoogle ScholarDigital LibraryDigital Library
  344. F. Tip and T. B. Dinesh. 2001. A slicing-based approach for locating type errors. ACM Transactions on Software Engineering and Methodology 10, 1 (Jan.), 5–55. Google ScholarGoogle ScholarDigital LibraryDigital Library
  345. Mads Tofte. 1987. Polymorphic References Revisited. March 1987. 7 pages. http://sml-family.org/history/Tofte-polyrefs-revisited-1987_03_09.pdf Archived at Internet Archive: https://web.archive.org/web/20200317201835/http://smlfamily.org/history/Tofte-poly-refs-revisited-1987_03_09.pdf (17 March 2020 20:18:35)Google ScholarGoogle Scholar
  346. Mads Tofte. 1988. Operational Semantics and Polymorphic Type Inference. Ph.D. Dissertation. Department of Computer Science, Univ. of Edinburgh (May). Available as Technical Report CST-52-88 and ECS-LFCS-88-54.Google ScholarGoogle Scholar
  347. Mads Tofte. 1989. Four Lectures on Standard ML. Technical Report ECS-LFCS-89-73. LFCS, Department of Computer Science, University of Edinburgh, Edinburgh, UK (March).Google ScholarGoogle Scholar
  348. Mads Tofte. 1990. Type inference for polymorphic references. Information and Computation 89, 1 (Nov.), 1–34. 10.1016/0890-5401(90)90018-DGoogle ScholarGoogle ScholarDigital LibraryDigital Library
  349. Mads Tofte and Lars Birkedal. 1998. A Region Inference Algorithm. ACM Transactions on Programming Languages and Systems 20, 4 (July), 734–767. Google ScholarGoogle ScholarDigital LibraryDigital Library
  350. Mads Tofte, Lars Birkedal, Martin Elsman, and Niels Hallenberg. 2004. A Retrospective on Region-Based Memory Management. Higher-order and Symbolic Computation 17, 3, 245–265. Google ScholarGoogle ScholarDigital LibraryDigital Library
  351. Mads Tofte and Jean-Pierre Talpin. 1994. Implementation of the Typed Call-by-value λ-calculus Using a Stack of Regions. In Conference Record of the 21st Annual ACM Symposium on Principles of Programming Languages (POPL ’94) (Portland, Oregon, USA). Association for Computing Machinery, New York, NY, USA (Jan.), 188–201. Google ScholarGoogle ScholarDigital LibraryDigital Library
  352. Mads Tofte and Jean-Pierre Talpin. 1997. Region-Based Memory Management. Information and Computation 132, 2, 109–176. Google ScholarGoogle ScholarDigital LibraryDigital Library
  353. Andrew Tolmach. 1994. Tag-free Garbage Collection Using Explicit Type Parameters. In Proceedings of the 1994 ACM Conference on Lisp and Functional Programming (LFP ’94) (Orlando, FL, USA). Association for Computing Machinery, New York, NY, USA (June), 1–11. Google ScholarGoogle ScholarDigital LibraryDigital Library
  354. Andrew Tolmach and Dino P. Oliva. 1998. From ML to Ada: Strongly-typed language interoperability via source translation. Journal of Functional Programming 8, 4 (July), 367–412. Google ScholarGoogle ScholarDigital LibraryDigital Library
  355. Andrew Peter Tolmach. 1992. Debugging Standard ML. Ph.D. Dissertation. Department of Computer Science, Princeton University, Princeton, NJ, USA.Google ScholarGoogle Scholar
  356. Jeffrey D. Ullman. 1998. Elements of ML Programming (ML97 ed.). Prentice-Hall, Upper Saddle River, NJ, USA.Google ScholarGoogle Scholar
  357. Unknown. 1991. Toward a standard Standard ML. . http://sml-family.org/history/std-charter.pdf Archived at Internet Archive: https://web.archive.org/web/20200313003228/http://sml-family.org/history/std-charter.pdf (13 March 2020 00:32:28) This document was written by someone in the Standard ML of New Jersey group; it was likely David MacQueen.Google ScholarGoogle Scholar
  358. A. van Wijngaarden et al. 1969. Report on the Algorithmic Language ALGOL 68. Technical Report. Mathematisch Centrum, Amsterdam.Google ScholarGoogle Scholar
  359. Myra VanInwegen. 1996. The Machine-Assisted Proof of Programming Language Properties. Ph.D. Dissertation. Univeristy of Pennsylvania. Advisor: Carl Gunter.Google ScholarGoogle Scholar
  360. M. VanInwegen and E. Gunter. 1993. HOL-ML. In 6th International Workshop on Higher order Logic Theorem Proving and Its Applications (Vancouver, Canada) (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA (Aug.), 61–73. Google ScholarGoogle ScholarCross RefCross Ref
  361. P. L. Wadler and S. Blott. 1989. How to make ad-hoc polymorphism less ad hoc. In Conference Record of the 16th Annual ACM Symposium on Principles of Programming Languages (POPL ’89) . Association for Computing Machinery, New York, NY, USA, 60–76. Google ScholarGoogle ScholarDigital LibraryDigital Library
  362. Christopher Wadsworth. 1983. ML, LCF, and HOPE. Polymorphism: The ML/LCF/Hope Newsletter I, 1 (Jan.), 5. http: //lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%201.pdf Archived at Internet Archive: https://web.archive. org/web/20190307022704/http://lucacardelli.name/Papers/Polymorphism%20Vol%20I,%20No%201.pdf (7 March 2019 02:27:04)Google ScholarGoogle Scholar
  363. D. Waltz. 1975. Understanding line drawings of scenes with shadows. In Psychology of Computer Vision, P. H. Winston (Ed.). McGraw-Hill, New York, NY, USA, 19–91.Google ScholarGoogle Scholar
  364. Mitchell Wand. 1986. Finding the Source of Type Errors. In Conference Record of the 13th Annual ACM Symposium on Principles of Programming Languages (POPL ’86) . Association for Computing Machinery, New York, NY, USA (Jan.), 38–43. Google ScholarGoogle ScholarDigital LibraryDigital Library
  365. Jeremy Wazny. 2006. Type inference and type error diagnosis for Hindley/Milner with extensions. Ph.D. Dissertation. Computer Science and Software Engineering, The University of Melbourne, Melbourne, Australia (Jan.).Google ScholarGoogle Scholar
  366. J. B. Wells, Allyn Dimock, Robert Muller, and Franklyn Turbak. 2002. A calculus with polymorphic and polyvariant flow types. Journal of Functional Programming 12, 3, 183–227. Google ScholarGoogle ScholarDigital LibraryDigital Library
  367. Sam Westrick, Rohan Yadav, Matthew Fluet, and Umut A. Acar. 2019. Disentanglement in Nested-Parallel Programs. Proceedings of the ACM on Programming Languages 4, POPL (Dec.), Article 47, 32 pages. Google ScholarGoogle ScholarDigital LibraryDigital Library
  368. Limsoon Wong. 2000. The Functional Guts of the Kleisli Query System. In Proceedings of the Fifth ACM SIGPLAN International Conference on Functional Programming (ICFP ’00) (Montreal, Canada). Association for Computing Machinery, New York, NY, USA (Sept.), 1–10. Google ScholarGoogle ScholarDigital LibraryDigital Library
  369. J. M. Wozencraft and Arthur Evans, Jr. 1970. Notes on Programming Linguistics. Technical Report. MIT Department of Electrical Engineering (Feb.).Google ScholarGoogle Scholar
  370. Andrew Wright. 1995. Simple imperative polymorphism. Journal of Lisp and Symbolic Computation 8, 4 (Dec.), 343–355. Google ScholarGoogle ScholarDigital LibraryDigital Library
  371. Andrew K. Wright. 1992. Typing References by Effect Inference. In Proceedings of the 4th European Symposium on Programming (ESOP ’92) (Rennes, France) (Lecture Notes in Computer Science). Springer-Verlag, New York, NY, USA (Feb.), 473–491. Google ScholarGoogle ScholarCross RefCross Ref
  372. Andrew K. Wright. 1993. Polymorphism for Imperative Languages without Imperative Types. Technical Report TR93-200. Rice University (Feb.).Google ScholarGoogle Scholar
  373. Andrew K. Wright and Matthias Felleisen. 1991. A Syntactic Approach to Type Soundness. Technical Report COMP TR91-160. Rice University (April).Google ScholarGoogle Scholar
  374. Baijun Wu, John Peter Campora III, and Sheng Chen. 2017. Learning User Friendly Type-Error Messages. Proceedings of the ACM on Programming Languages 1, OOPSLA (Oct.), Article 106, 29 pages. Google ScholarGoogle ScholarDigital LibraryDigital Library
  375. William A. Wulf, Ralph L. London, and Mary Shaw. 1976. An Introduction to the Construction and Verification of Alphard Programs. IEEE Transactions on Software Engineering SE-2, 4 (Dec.), 253–265. Google ScholarGoogle ScholarDigital LibraryDigital Library
  376. Danfeng Zhang and Andrew C. Myers. 2014. Towards general diagnosis of static errors. In Proceedings of the 41st Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages . Association for Computing Machinery, New York, NY, USA (Jan.), 569–581. Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. The history of Standard ML

              Recommendations

              Comments

              Login options

              Check if you have access through your login credentials or your institution to get full access on this article.

              Sign in

              Full Access

              • Published in

                cover image Proceedings of the ACM on Programming Languages
                Proceedings of the ACM on Programming Languages  Volume 4, Issue HOPL
                June 2020
                1524 pages
                EISSN:2475-1421
                DOI:10.1145/3406494
                Issue’s Table of Contents

                Copyright © 2020 Owner/Author

                This work is licensed under a Creative Commons Attribution International 4.0 License.

                Publisher

                Association for Computing Machinery

                New York, NY, United States

                Publication History

                • Published: 12 June 2020
                • Online AM: 7 May 2020
                Published in pacmpl Volume 4, Issue HOPL

                Permissions

                Request permissions about this article.

                Request Permissions

                Check for updates

                Qualifiers

                • research-article

              PDF Format

              View or Download as a PDF file.

              PDF

              eReader

              View online with eReader.

              eReader