Bibliography

Augustsson, L. (1985). Compiling pattern matching. Functional Programming Languages and Computer Architecture (FPCA).

Augustsson, L., Breitner, J., Claessen, K., Jhala, R., Peyton Jones, S., Shivers, O., Steele, G. L., & Sweeney, T. (2023). The Verse calculus: A core calculus for deterministic functional logic programming. Proceedings of the ACM on Programming Languages, 7(ICFP).

Bauer, A., & Pretnar, M. (2015). Programming with algebraic effects and handlers. Journal of Logical and Algebraic Methods in Programming, 84(1), 108-123.

Barendsen, E., & Smetsers, S. (1993). Conventional and uniqueness typing in graph rewrite systems. Foundations of Software Technology and Theoretical Computer Science (FSTTCS).

Biernacki, D., Piróg, M., Polesiuk, P., & Sieczkowski, F. (2018). Handle with care: Relational interpretation of algebraic effects and handlers. Proceedings of the ACM on Programming Languages, 2(POPL).

Bour, F., Clément, B., & Scherer, G. (2021). Tail modulo cons. Journées Francophones des Langages Applicatifs (JFLA).

Coutts, D., Leshchinskiy, R., & Stewart, D. (2007). Stream fusion: From lists to streams to nothing at all. International Conference on Functional Programming (ICFP).

Damas, L., & Milner, R. (1982). Principal type-schemes for functional programs. Principles of Programming Languages (POPL), 207-212.

de Moura, L., & Ullrich, S. (2021). The Lean 4 theorem prover and programming language. Conference on Automated Deduction (CADE).

Dreyer, D., Harper, R., Chakravarty, M. M. T., & Keller, G. (2007). Modular type classes. Principles of Programming Languages (POPL).

Dunfield, J., & Krishnaswami, N. R. (2013). Complete and easy bidirectional typechecking for higher-rank polymorphism. International Conference on Functional Programming (ICFP).

Felleisen, M., & Friedman, D. P. (1986). Control operators, the SECD-machine, and the lambda-calculus. Formal Description of Programming Concepts III, 193-217.

Flanagan, C., Sabry, A., Duba, B. F., & Felleisen, M. (1993). The essence of compiling with continuations. Programming Language Design and Implementation (PLDI).

Foster, J. N., Greenwald, M. B., Moore, J. T., Pierce, B. C., & Schmitt, A. (2007). Combinators for bidirectional tree transformations: A linguistic approach to the view-update problem. ACM Transactions on Programming Languages and Systems, 29(3).

Friedman, D. P., & Wise, D. S. (1975). Unwinding stylized recursions into iterations (Technical Report 19). Indiana University.

Gibbons, J., & Oliveira, B. C. d. S. (2009). The essence of the iterator pattern. Journal of Functional Programming, 19(3-4), 377-402.

Gill, A., Launchbury, J., & Peyton Jones, S. L. (1993). A short cut to deforestation. Functional Programming Languages and Computer Architecture (FPCA).

Harper, R., & Lillibridge, M. (1994). A type-theoretic approach to higher-order modules with sharing. Principles of Programming Languages (POPL).

Hindley, R. (1969). The principal type-scheme of an object in combinatory logic. Transactions of the American Mathematical Society, 146, 29-60.

Kiselyov, O., & Ishii, H. (2015). Freer monads, more extensible effects. Haskell Symposium.

Kiselyov, O., Sabry, A., & Swords, C. (2013). Extensible effects: An alternative to monad transformers. Haskell Symposium.

Lattner, C., & Adve, V. (2004). LLVM: A compilation framework for lifelong program analysis & transformation. International Symposium on Code Generation and Optimization (CGO).

Leijen, D. (2005). Extensible records with scoped labels. Trends in Functional Programming (TFP).

Leijen, D. (2017). Type directed compilation of row-typed algebraic effects. Principles of Programming Languages (POPL).

Leroy, X. (1994). Manifest types, modules, and separate compilation. Principles of Programming Languages (POPL).

Leroy, X. (2009). Formal verification of a realistic compiler. Communications of the ACM, 52(7), 107-115.

Levy, P. B. (2004). Call-by-push-value: A functional/imperative synthesis. Springer.

Lorenzen, A., & Leijen, D. (2022). Reference counting with frame limited reuse. Proceedings of the ACM on Programming Languages, 6(ICFP), 357-380.

Lorenzen, A., Leijen, D., & Swierstra, W. (2023). FP^2: Fully in-place functional programming. Proceedings of the ACM on Programming Languages, 7(ICFP).

Maranget, L. (2007). Warnings for pattern matching. Journal of Functional Programming, 17(3), 387-421.

Maranget, L. (2008). Compiling pattern matching to good decision trees. ML Workshop.

McBride, C., & Paterson, R. (2008). Applicative programming with effects. Journal of Functional Programming, 18(1), 1-13.

McKeeman, W. M. (1998). Differential testing for software. Digital Technical Journal, 10(1), 100-107.

Milner, R. (1978). A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17(3), 348-375.

Najd, S., & Peyton Jones, S. (2017). Trees that grow. Journal of Universal Computer Science, 23(1), 42-62.

Necula, G. C. (2000). Translation validation for an optimizing compiler. Programming Language Design and Implementation (PLDI).

Peterson, J., & Jones, M. P. (1993). Implementing type classes. Programming Language Design and Implementation (PLDI).

Pickering, M., Érdi, G., Peyton Jones, S., & Eisenberg, R. A. (2016). Pattern synonyms. Haskell Symposium.

Pierce, B. C., & Turner, D. N. (2000). Local type inference. ACM Transactions on Programming Languages and Systems, 22(1), 1-44.

Plotkin, G. D. (1981). A structural approach to operational semantics (Technical Report DAIMI FN-19). Aarhus University.

Plotkin, G., & Power, J. (2001). Adequacy for algebraic effects. Foundations of Software Science and Computation Structures (FoSSaCS).

Plotkin, G., & Power, J. (2003). Algebraic operations and generic effects. Applied Categorical Structures, 11(1), 69-94.

Plotkin, G., & Pretnar, M. (2009). Handlers of algebraic effects. European Symposium on Programming (ESOP).

Pnueli, A., Siegel, M., & Singerman, E. (1998). Translation validation. Tools and Algorithms for the Construction and Analysis of Systems (TACAS).

Reinking, A., Xie, N., de Moura, L., & Leijen, D. (2021). Perceus: Garbage free reference counting with reuse. Programming Language Design and Implementation (PLDI).

Sulzmann, M., Chakravarty, M. M. T., Peyton Jones, S., & Donnelly, K. (2007). System F with type equality coercions. Types in Language Design and Implementation (TLDI).

Swierstra, W. (2008). Data types à la carte. Journal of Functional Programming, 18(4), 423-436.

Wand, M. (1987). Complete type inference for simple objects. Logic in Computer Science (LICS).

Weeks, S. (2006). Whole-program compilation in MLton. ML Workshop.

White, L., Bour, F., & Yallop, J. (2015). Modular implicits. Electronic Proceedings in Theoretical Computer Science, 198, 22-63.

Wu, N., Schrijvers, T., & Hinze, R. (2014). Effect handlers in scope. Haskell Symposium.

Xie, N., Brachthäuser, J. I., Hillerström, D., Schuster, P., & Leijen, D. (2020). Effect handlers, evidently. Proceedings of the ACM on Programming Languages, 4(ICFP).

Xie, N., & Leijen, D. (2021). Generalized evidence passing for effect handlers. Proceedings of the ACM on Programming Languages, 5(ICFP).

Yang, X., Chen, Y., Eide, E., & Regehr, J. (2011). Finding and understanding bugs in C compilers. Programming Language Design and Implementation (PLDI).