skip to main content

Program adverbs and Tlön embeddings

Published:31 August 2022Publication History
Skip Abstract Section

Abstract

Free monads (and their variants) have become a popular general-purpose tool for representing the semantics of effectful programs in proof assistants. These data structures support the compositional definition of semantics parameterized by uninterpreted events, while admitting a rich equational theory of equivalence. But monads are not the only way to structure effectful computation, why should we limit ourselves?

In this paper, inspired by applicative functors, selective functors, and other structures, we define a collection of data structures and theories, which we call program adverbs, that capture a variety of computational patterns. Program adverbs are themselves composable, allowing them to be used to specify the semantics of languages with multiple computation patterns. We use program adverbs as the basis for a new class of semantic embeddings called Tlön embeddings. Compared with embeddings based on free monads, Tlön embeddings allow more flexibility in computational modeling of effects, while retaining more information about the program's syntactic structure.

References

  1. Michael Gordon Abbott, Thorsten Altenkirch, and Neil Ghani. 2003. Categories of Containers. In Foundations of Software Science and Computational Structures, 6th International Conference, FOSSACS 2003 Held as Part of the Joint European Conference on Theory and Practice of Software, ETAPS 2003, Warsaw, Poland, April 7-11, 2003, Proceedings, Andrew D. Gordon (Ed.) (Lecture Notes in Computer Science, Vol. 2620). Springer, 23–38. https://doi.org/10.1007/3-540-36576-1_2 Google ScholarGoogle Scholar
  2. Danel Ahman and Tarmo Uustalu. 2013. Update Monads: Cointerpreting Directed Containers. In 19th International Conference on Types for Proofs and Programs, TYPES 2013, April 22-26, 2013, Toulouse, France, Ralph Matthes and Aleksy Schubert (Eds.) (LIPIcs, Vol. 26). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 1–23. https://doi.org/10.4230/LIPIcs.TYPES.2013.1 Google ScholarGoogle ScholarCross RefCross Ref
  3. Andrew W. Appel, Robert Dockins, Aquinas Hobor, Lennart Beringer, Josiah Dodds, Gordon Stewart, Sandrine Blazy, and Xavier Leroy. 2014. Program Logics for Certified Compilers. Cambridge University Press. isbn:978-1-10-704801-0 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Brian E. Aydemir, Aaron Bohannon, Matthew Fairbairn, J. Nathan Foster, Benjamin C. Pierce, Peter Sewell, Dimitrios Vytiniotis, Geoffrey Washburn, Stephanie Weirich, and Steve Zdancewic. 2005. Mechanized Metatheory for the Masses: The POPLMARK Challenge. In Theorem Proving in Higher Order Logics, 18th International Conference, TPHOLs 2005, Oxford, UK, August 22-25, 2005, Proceedings. 50–65. https://doi.org/10.1007/11541868_4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Jorge Luis Borges. 1940. Tlön, Uqbar, Orbis Tertius. In Labyrinths: Selected Stories & Other Writings, Donald A. Yates and James E. Irby (Eds.). The story was translated by James E. Irby. It first appeared in New World Writing No. 18, 1961. The book was first published in 1962 Google ScholarGoogle Scholar
  6. Richard J. Boulton, Andrew D. Gordon, Michael J. C. Gordon, John Harrison, John Herbert, and John Van Tassel. 1992. Experience with Embedding Hardware Description Languages in HOL. In Theorem Provers in Circuit Design, Proceedings of the IFIP TC10/WG 10.2 International Conference on Theorem Provers in Circuit Design: Theory, Practice and Experience, Nijmegen, The Netherlands, 22-24 June 1992, Proceedings, Victoria Stavridou, Thomas F. Melham, and Raymond T. Boute (Eds.) (IFIP Transactions, Vol. A-10). North-Holland, 129–156. Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Joachim Breitner, Antal Spector-Zabusky, Yao Li, Christine Rizkallah, John Wiegley, Joshua Cohen, and Stephanie Weirich. 2021. Ready, Set, Verify! Applying hs-to-coq to real-world Haskell code. Journal of Functional Programming, 31 (2021), e5. https://doi.org/10.1017/S0956796820000283 Google ScholarGoogle ScholarCross RefCross Ref
  8. Venanzio Capretta. 2005. General recursion via coinductive types. Log. Methods Comput. Sci., 1, 2 (2005), https://doi.org/10.2168/LMCS-1(2:1)2005 Google ScholarGoogle Scholar
  9. Paolo Capriotti and Ambrus Kaposi. 2014. Free Applicative Functors. In Proceedings 5th Workshop on Mathematically Structured Functional Programming, [email protected] 2014, Grenoble, France, 12 April 2014, Paul Levy and Neel Krishnaswami (Eds.) (EPTCS, Vol. 153). 2–30. https://doi.org/10.4204/EPTCS.153.2 Google ScholarGoogle ScholarCross RefCross Ref
  10. Adam Chlipala. 2021. Skipping the binder bureaucracy with mixed embeddings in a semantics course (functional pearl). Proc. ACM Program. Lang., 5, ICFP (2021), 1–28. https://doi.org/10.1145/3473599 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Jan Christiansen, Sandra Dylus, and Niels Bunkenburg. 2019. Verifying effectful Haskell programs in Coq. In Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell, [email protected] 2019, Berlin, Germany, August 18-23, 2019, Richard A. Eisenberg (Ed.). ACM, 125–138. https://doi.org/10.1145/3331545.3342592 Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Bruno C. d. S. Oliveira. 2009. Modular Visitor Components. In ECOOP 2009 - Object-Oriented Programming, 23rd European Conference, Genoa, Italy, July 6-10, 2009. Proceedings, Sophia Drossopoulou (Ed.) (Lecture Notes in Computer Science, Vol. 5653). Springer, 269–293. https://doi.org/10.1007/978-3-642-03013-0_13 Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Benjamin Delaware, Bruno C. d. S. Oliveira, and Tom Schrijvers. 2013. Meta-theory à la carte. In The 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL ’13, Rome, Italy - January 23 - 25, 2013, Roberto Giacobazzi and Radhia Cousot (Eds.). ACM, 207–218. https://doi.org/10.1145/2429069.2429094 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. Sandra Dylus, Jan Christiansen, and Finn Teegen. 2019. One Monad to Prove Them All. Art Sci. Eng. Program., 3, 3 (2019), 8. https://doi.org/10.22152/programming-journal.org/2019/3/8 Google ScholarGoogle ScholarCross RefCross Ref
  15. Erik Ernst. 2001. Family Polymorphism. In ECOOP 2001 - Object-Oriented Programming, 15th European Conference, Budapest, Hungary, June 18-22, 2001, Proceedings, Jørgen Lindskov Knudsen (Ed.) (Lecture Notes in Computer Science, Vol. 2072). Springer, 303–326. https://doi.org/10.1007/3-540-45337-7_17 Google ScholarGoogle ScholarCross RefCross Ref
  16. Yannick Forster and Kathrin Stark. 2020. Coq à la carte: a practical approach to modular syntax with binders. In Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs, CPP 2020, New Orleans, LA, USA, January 20-21, 2020, Jasmin Blanchette and Catalin Hritcu (Eds.). ACM, 186–200. https://doi.org/10.1145/3372885.3373817 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Simon Foster, Chung-Kil Hur, and Jim Woodcock. 2021. Formally Verified Simulations of State-Rich Processes using Interaction Trees in Isabelle/HOL. CoRR, abs/2105.05133 (2021), arxiv:2105.05133. arxiv:2105.05133 Google ScholarGoogle Scholar
  18. Ronghui Gu, Zhong Shao, Hao Chen, Jieung Kim, Jérémie Koenig, Xiongnan (Newman) Wu, Vilhelm Sjöberg, and David Costanzo. 2019. Building certified concurrent OS kernels. Commun. ACM, 62, 10 (2019), 89–99. https://doi.org/10.1145/3356903 Google ScholarGoogle ScholarDigital LibraryDigital Library
  19. Ronghui Gu, Zhong Shao, Jieung Kim, Xiongnan (Newman) Wu, Jérémie Koenig, Vilhelm Sjöberg, Hao Chen, David Costanzo, and Tahina Ramananandro. 2018. Certified concurrent abstraction layers. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2018, Philadelphia, PA, USA, June 18-22, 2018, Jeffrey S. Foster and Dan Grossman (Eds.). ACM, 646–661. https://doi.org/10.1145/3192366.3192381 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. John Hughes. 2000. Generalising monads to arrows. Sci. Comput. Program., 37, 1-3 (2000), 67–111. https://doi.org/10.1016/S0167-6423(99)00023-4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Mark P. Jones. 1995. Functional Programming with Overloading and Higher-Order Polymorphism. In Advanced Functional Programming, First International Spring School on Advanced Functional Programming Techniques, Båstad, Sweden, May 24-30, 1995, Tutorial Text, Johan Jeuring and Erik Meijer (Eds.) (Lecture Notes in Computer Science, Vol. 925). Springer, 97–136. https://doi.org/10.1007/3-540-59451-5_4 Google ScholarGoogle Scholar
  22. Oleg Kiselyov and Hiromi Ishii. 2015. Freer monads, more extensible effects. In Proceedings of the 8th ACM SIGPLAN Symposium on Haskell, Haskell 2015, Vancouver, BC, Canada, September 3-4, 2015. 94–105. https://doi.org/10.1145/2804302.2804319 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Nicolas Koh, Yao Li, Yishuai Li, Li-yao Xia, Lennart Beringer, Wolf Honoré, William Mansky, Benjamin C. Pierce, and Steve Zdancewic. 2019. From C to interaction trees: specifying, verifying, and testing a networked server. In Proceedings of the 8th ACM SIGPLAN International Conference on Certified Programs and Proofs, CPP 2019, Cascais, Portugal, January 14-15, 2019, Assia Mahboubi and Magnus O. Myreen (Eds.). ACM, 234–248. https://doi.org/10.1145/3293880.3294106 Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Anastasiya Kravchuk-Kirilyuk, Yizhou Zhang, and Nada Amin. 2021. Family Polymorphism for Proof Extensibility. In Proceedings of the 27th International Conference on Types for Proofs and Programs, TYPES 2021, June 14–18, 2021. https://types21.liacs.nl/download/family-polymorphism-for-proof-extensibility/ Google ScholarGoogle Scholar
  25. Leonidas Lampropoulos, Zoe Paraskevopoulou, and Benjamin C. Pierce. 2018. Generating good generators for inductive relations. Proc. ACM Program. Lang., 2, POPL (2018), 45:1–45:30. https://doi.org/10.1145/3158133 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Mohsen Lesani, Li-yao Xia, Anders Kaseorg, Christian J. Bell, Adam Chlipala, Benjamin C. Pierce, and Steve Zdancewic. 2022. C4: verified transactional objects. Proc. ACM Program. Lang., 6, OOPSLA (2022), 1–31. https://doi.org/10.1145/3527324 Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Thomas Letan, Yann Régis-Gianas, Pierre Chifflier, and Guillaume Hiet. 2021. Modular verification of programs with effects and effects handlers. Formal Aspects Comput., 33, 1 (2021), 127–150. https://doi.org/10.1007/s00165-020-00523-2 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Yao Li and Stephanie Weirich. 2022. Program Adverbs and Tlön Embeddings (artifact). https://doi.org/10.5281/zenodo.6678339 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Sam Lindley, Philip Wadler, and Jeremy Yallop. 2011. Idioms are Oblivious, Arrows are Meticulous, Monads are Promiscuous. Electron. Notes Theor. Comput. Sci., 229, 5 (2011), 97–117. https://doi.org/10.1016/j.entcs.2011.02.018 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Jacob R. Lorch, Yixuan Chen, Manos Kapritsos, Bryan Parno, Shaz Qadeer, Upamanyu Sharma, James R. Wilcox, and Xueyuan Zhao. 2020. Armada: low-effort verification of high-performance concurrent programs. In Proceedings of the 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2020, London, UK, June 15-20, 2020, Alastair F. Donaldson and Emina Torlak (Eds.). ACM, 197–210. https://doi.org/10.1145/3385412.3385971 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Kenji Maillard, Danel Ahman, Robert Atkey, Guido Martínez, Catalin Hritcu, Exequiel Rivas, and Éric Tanter. 2019. Dijkstra monads for all. Proc. ACM Program. Lang., 3, ICFP (2019), 104:1–104:29. https://doi.org/10.1145/3341708 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. William Mansky, Wolf Honoré, and Andrew W. Appel. 2020. Connecting Higher-Order Separation Logic to a First-Order Outside World. In Programming Languages and Systems - 29th European Symposium on Programming, ESOP 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020, Dublin, Ireland, April 25-30, 2020, Proceedings, Peter Müller (Ed.) (Lecture Notes in Computer Science, Vol. 12075). Springer, 428–455. https://doi.org/10.1007/978-3-030-44914-8_16 Google ScholarGoogle ScholarDigital LibraryDigital Library
  33. Simon Marlow, Louis Brandy, Jonathan Coens, and Jon Purdy. 2014. There is no fork: an abstraction for efficient, concurrent, and concise data access. In Proceedings of the 19th ACM SIGPLAN international conference on Functional programming, Gothenburg, Sweden, September 1-3, 2014, Johan Jeuring and Manuel M. T. Chakravarty (Eds.). ACM, 325–337. https://doi.org/10.1145/2628136.2628144 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Coq development team. 2022. The Coq proof assistant. http://coq.inria.fr Version 8.15.1 Google ScholarGoogle Scholar
  35. Conor McBride. 2015. Turing-Completeness Totally Free. In Mathematics of Program Construction - 12th International Conference, MPC 2015, Königswinter, Germany, June 29 - July 1, 2015. Proceedings. 257–275. https://doi.org/10.1007/978-3-319-19797-5_13 Google ScholarGoogle ScholarCross RefCross Ref
  36. Conor McBride and Ross Paterson. 2008. Applicative programming with effects. J. Funct. Program., 18, 1 (2008), 1–13. https://doi.org/10.1017/S0956796807006326 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Bartosz Milewski. 2018. Free Monoidal Functors, Categorically!. https://bartoszmilewski.com/2018/05/16/free-monoidal-functors-categorically/ Blog post Google ScholarGoogle Scholar
  38. Eugenio Moggi. 1991. Notions of Computation and Monads. Inf. Comput., 93, 1 (1991), 55–92. https://doi.org/10.1016/0890-5401(91)90052-4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Andrey Mokhov. 2019. Implementation of selective applicative functors in Haskell. https://hackage.haskell.org/package/selective Google ScholarGoogle Scholar
  40. Andrey Mokhov, Georgy Lukyanov, Simon Marlow, and Jerémie Dimino. 2019. Selective applicative functors. Proc. ACM Program. Lang., 3, ICFP (2019), 90:1–90:29. https://doi.org/10.1145/3341694 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Andrey Mokhov, Neil Mitchell, and Simon Peyton Jones. 2020. Build systems à la carte: Theory and practice. J. Funct. Program., 30 (2020), e11. https://doi.org/10.1017/S0956796820000088 Google ScholarGoogle ScholarCross RefCross Ref
  42. Pierre Nigron and Pierre-Évariste Dagand. 2021. Reaching for the Star: Tale of a Monad in Coq. In 12th International Conference on Interactive Theorem Proving, ITP 2021, June 29 to July 1, 2021, Rome, Italy (Virtual Conference), Liron Cohen and Cezary Kaliszyk (Eds.) (LIPIcs, Vol. 193). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 29:1–29:19. https://doi.org/10.4230/LIPIcs.ITP.2021.29 Google ScholarGoogle ScholarCross RefCross Ref
  43. Vivek S. Pai, Peter Druschel, and Willy Zwaenepoel. 1999. Flash: An efficient and portable Web server. In Proceedings of the 1999 USENIX Annual Technical Conference, June 6-11, 1999, Monterey, California, USA. USENIX, 199–212. http://www.usenix.org/events/usenix99/full_papers/pai/pai.pdf Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Zoe Paraskevopoulou, Aaron Eline, and Leonidas Lampropoulos. 2022. Computing correctly with inductive relations. In PLDI ’22: 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, San Diego, CA, USA, June 13 - 17, 2022, Ranjit Jhala and Isil Dillig (Eds.). ACM, 966–980. https://doi.org/10.1145/3519939.3523707 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Maciej Piróg and Jeremy Gibbons. 2014. The Coinductive Resumption Monad. In Proceedings of the 30th Conference on the Mathematical Foundations of Programming Semantics, MFPS 2014, Ithaca, NY, USA, June 12-15, 2014, Bart Jacobs, Alexandra Silva, and Sam Staton (Eds.) (Electronic Notes in Theoretical Computer Science, Vol. 308). Elsevier, 273–288. https://doi.org/10.1016/j.entcs.2014.10.015 Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Jacob Prinz, G. A. Kavvos, and Leonidas Lampropoulos. 2022. Deeper Shallow Embeddings. In 13th International Conference on Interactive Theorem Proving, ITP 2022, August 7 to August 10, 2022, Haifa, Israel (LIPIcs). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 19:1–19:18. https://doi.org/10.4230/LIPIcs.ITP.2022.19 Google ScholarGoogle ScholarCross RefCross Ref
  47. Lucas Silver and Steve Zdancewic. 2021. Dijkstra monads forever: termination-sensitive specifications for interaction trees. Proc. ACM Program. Lang., 5, POPL (2021), 1–28. https://doi.org/10.1145/3434307 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Matthieu Sozeau and Cyprien Mangin. 2019. Equations reloaded: high-level dependently-typed functional programming and proving in Coq. Proc. ACM Program. Lang., 3, ICFP (2019), 86:1–86:29. https://doi.org/10.1145/3341690 Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Antal Spector-Zabusky, Joachim Breitner, Christine Rizkallah, and Stephanie Weirich. 2018. Total Haskell is reasonable Coq. In Proceedings of the 7th ACM SIGPLAN International Conference on Certified Programs and Proofs, CPP 2018, Los Angeles, CA, USA, January 8-9, 2018, June Andronick and Amy P. Felty (Eds.). ACM, 14–27. https://doi.org/10.1145/3167092 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Josef Svenningsson and Emil Axelsson. 2012. Combining Deep and Shallow Embedding for EDSL. In Trends in Functional Programming - 13th International Symposium, TFP 2012, St. Andrews, UK, June 12-14, 2012, Revised Selected Papers, Hans-Wolfgang Loidl and Ricardo Peña (Eds.) (Lecture Notes in Computer Science, Vol. 7829). Springer, 21–36. https://doi.org/10.1007/978-3-642-40447-4_2 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Nikhil Swamy, Aseem Rastogi, Aymeric Fromherz, Denis Merigoux, Danel Ahman, and Guido Martínez. 2020. SteelCore: an extensible concurrent separation logic for effectful dependently typed programs. Proc. ACM Program. Lang., 4, ICFP (2020), 121:1–121:30. https://doi.org/10.1145/3409003 Google ScholarGoogle ScholarDigital LibraryDigital Library
  52. Nikhil Swamy, Joel Weinberger, Cole Schlesinger, Juan Chen, and Benjamin Livshits. 2013. Verifying higher-order programs with the dijkstra monad. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13, Seattle, WA, USA, June 16-19, 2013, Hans-Juergen Boehm and Cormac Flanagan (Eds.). ACM, 387–398. https://doi.org/10.1145/2491956.2491978 Google ScholarGoogle ScholarDigital LibraryDigital Library
  53. S. Doaitse Swierstra and Luc Duponcheel. 1996. Deterministic, Error-Correcting Combinator Parsers. In Advanced Functional Programming, Second International School, Olympia, WA, USA, August 26-30, 1996, Tutorial Text, John Launchbury, Erik Meijer, and Tim Sheard (Eds.) (Lecture Notes in Computer Science, Vol. 1129). Springer, 184–207. https://doi.org/10.1007/3-540-61628-4_7 Google ScholarGoogle ScholarCross RefCross Ref
  54. Wouter Swierstra and Tim Baanen. 2019. A predicate transformer semantics for effects (functional pearl). Proc. ACM Program. Lang., 3, ICFP (2019), 103:1–103:26. https://doi.org/10.1145/3341707 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Philip Wadler. 1990. Recursive types for free!. http://homepages.inf.ed.ac.uk/wadler/papers/free-rectypes/free-rectypes.txt Draft Google ScholarGoogle Scholar
  56. Philip Wadler. 1992. Comprehending Monads. Math. Struct. Comput. Sci., 2, 4 (1992), 461–493. https://doi.org/10.1017/S0960129500001560 Google ScholarGoogle ScholarCross RefCross Ref
  57. Philip Wadler. 1998. The Expression Problem. http://homepages.inf.ed.ac.uk/wadler/papers/expression/expression.txt Email correspondence Google ScholarGoogle Scholar
  58. Jamie Willis, Nicolas Wu, and Matthew Pickering. 2020. Staged selective parser combinators. Proc. ACM Program. Lang., 4, ICFP (2020), 120:1–120:30. https://doi.org/10.1145/3409002 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Li-yao Xia. 2019. Free applicative functors in Coq. https://blog.poisson.chat/posts/2019-07-14-free-applicative-functors.html Blog post Google ScholarGoogle Scholar
  60. Li-yao Xia, Yannick Zakowski, Paul He, Chung-Kil Hur, Gregory Malecha, Benjamin C. Pierce, and Steve Zdancewic. 2020. Interaction trees: representing recursive and impure programs in Coq. Proc. ACM Program. Lang., 4, POPL (2020), 51:1–51:32. https://doi.org/10.1145/3371119 Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Kangfeng Ye, Simon Foster, and Jim Woodcock. 2022. Formally Verified Animation for RoboChart using Interaction Trees. In The 23rd International Conference on Formal Engineering Methods. Springer Science and Business Media Deutschland GmbH. https://eprints.whiterose.ac.uk/188566/ Google ScholarGoogle Scholar
  62. Irene Yoon, Yannick Zakowski, and Steve Zdancewic. 2022. Formal reasoning about layered monadic interpreters. Proc. ACM Program. Lang., 6, ICFP (2022), https://doi.org/10.1145/3547632 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Yannick Zakowski, Calvin Beck, Irene Yoon, Ilia Zaichuk, Vadim Zaliva, and Steve Zdancewic. 2021. Modular, compositional, and executable formal semantics for LLVM IR. Proc. ACM Program. Lang., 5, ICFP (2021), 1–30. https://doi.org/10.1145/3473572 Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Yannick Zakowski, Paul He, Chung-Kil Hur, and Steve Zdancewic. 2020. An equational theory for weak bisimulation via generalized parameterized coinduction. In Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs, CPP 2020, New Orleans, LA, USA, January 20-21, 2020, Jasmin Blanchette and Catalin Hritcu (Eds.). ACM, 71–84. https://doi.org/10.1145/3372885.3373813 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. Hengchu Zhang, Wolf Honoré, Nicolas Koh, Yao Li, Yishuai Li, Li-yao Xia, Lennart Beringer, William Mansky, Benjamin C. Pierce, and Steve Zdancewic. 2021. Verifying an HTTP Key-Value Server with Interaction Trees and VST. In 12th International Conference on Interactive Theorem Proving, ITP 2021, June 29 to July 1, 2021, Rome, Italy (Virtual Conference), Liron Cohen and Cezary Kaliszyk (Eds.) (LIPIcs, Vol. 193). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 32:1–32:19. https://doi.org/10.4230/LIPIcs.ITP.2021.32 Google ScholarGoogle Scholar

Index Terms

  1. Program adverbs and Tlön embeddings

          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

          PDF Format

          View or Download as a PDF file.

          PDF

          eReader

          View online with eReader.

          eReader
          About Cookies On This Site

          We use cookies to ensure that we give you the best experience on our website.

          Learn more

          Got it!