MIL, a Monadic Intermediate Language for Implementing Functional Languages

ABSTRACT

This paper describes MIL, a "monadic intermediate language" that is designed for use in optimizing compilers for strict, strongly typed functional languages. By using a notation that exposes the construction and use of closures and algebraic datatype values, for example, the MIL optimizer is able to detect and eliminate many unnecessary uses of these structures prior to code generation. One feature that distinguishes MIL from other intermediate languages in this area is the use of a typed, parameterized notion for basic blocks. This both enables new optimization techniques, such as the ability to create specialized versions of basic blocks, and leads to a new approach for implementing changes in data representation.

References

1. Andrew W. Appel. 1992. Compiling with Continuations. Cambridge University Press, New York, NY, USA.
2. Justin Bailey. 2012. Using Dataflow Optimization Techniques with a Monadic Intermediate Language. Master's thesis. Department of Computer Science, Portland State University, Portland, OR.
3. Adam Chlipala. 2015. An Optimizing Compiler for a Purely Functional Web-application Language. In Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming (ICFP 2015). ACM, New York, NY, USA.
4. Iavor S. Diatchki, Mark P. Jones, and Rebekah Leslie. 2005. High-level views on low-level representations. In Proceedings of the 10th ACM SIGPLAN International Conference on Functional Programming, ICFP 2005, Tallinn, Estonia, September 26-28, 2005. ACM, 168--179.
5. Matthew Fluet and Stephen Weeks. 2001. Contification Using Dominators. In Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming (ICFP '01). ACM, New York, NY, USA, 2--13.
6. Thomas Johnsson. 1985. Lambda Lifting: Transforming Programs to Recursive Equations. In Proceedings of the IFIP conference on Functional Programming Languages and Computer Architecture (Lecture Notes in Computer Science, 201). Springer-Verlag, 190--203.
7. Mark P. Jones. 1994. Dictionary-free Overloading by Partial Evaluation. In ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation (PEPM '94).
8. Andrew Kennedy. 2007. Compiling with Continuations, Continued. In Proceedings of the 12th ACM SIGPLAN International Conference on Functional Programming (ICFP '07). ACM, New York, NY, USA, 177--190.
9. Chris Lattner. 2002. LLVM: An Infrastructure for Multi-Stage Optimization. Master's thesis. Computer Science Dept., University of Illinois at Urbana-Champaign, Urbana, IL.
10. LLVM 2018. The LLVM Compiler Infrastructure. http://llvm.org.
11. Luke Maurer, Zena Ariola, Paul Downen, and Simon Peyton Jones. 2017. Compiling without continuations. In ACM Conference on Programming Languages Design and Implementation (PLDI'17). ACM, 482--494.
12. E. Moggi. 1989. Computational Lambda-calculus and Monads. In Proceedings of the Fourth Annual Symposium on Logic in Computer Science. IEEE Press, Piscataway, NJ, USA, 14--23.
13. Alan Mycroft. 1984. Polymorphic Type Schemes and Recursive Definitions. In Proceedings of the 6th Colloquium on International Symposium on Programming. Springer-Verlag, London, UK, UK, 217--228.
14. Simon Peyton Jones (Ed.). 2003. Haskell 98 Language and Libraries -- The Revised Report. Cambridge University Press.
15. The Hasp Project. 2010. The Habit Programming Language: The Revised Preliminary Report. http://github.com/habit-lang/language-report.
16. Philip Wadler. 1990. Comprehending Monads. In Proceedings of the 1990 ACM Conference on LISP and Functional Programming (LFP '90). 61--78.
17. Stephen Weeks. 2006. Whole-program Compilation in MLton. In Proceedings of the 2006 Workshop on ML (ML '06). ACM, New York, NY, USA.

Index Terms

• Software and its engineering

  • Software notations and tools

    • Compilers

    • General programming languages

      • Language types

        • Functional languages