skip to main content
research-article
Open Access

Reachability types: tracking aliasing and separation in higher-order functional programs

Published:15 October 2021Publication History
Skip Abstract Section

Abstract

Ownership type systems, based on the idea of enforcing unique access paths, have been primarily focused on objects and top-level classes. However, existing models do not as readily reflect the finer aspects of nested lexical scopes, capturing, or escaping closures in higher-order functional programming patterns, which are increasingly adopted even in mainstream object-oriented languages. We present a new type system, λ* , which enables expressive ownership-style reasoning across higher-order functions. It tracks sharing and separation through reachability sets, and layers additional mechanisms for selectively enforcing uniqueness on top of it. Based on reachability sets, we extend the type system with an expressive flow-sensitive effect system, which enables flavors of move semantics and ownership transfer. In addition, we present several case studies and extensions, including applications to capabilities for algebraic effects, one-shot continuations, and safe parallelization.

Skip Supplemental Material Section

Supplemental Material

Auxiliary Presentation Video

Ownership type systems, based on the idea of enforcing unique access paths, have been primarily focused on objects and top-level classes. However, existing models do not as readily reflect the finer aspects of nested lexical scopes, capturing, or escaping closures in higher-order functional programming patterns, which are increasingly adopted even in mainstream object-oriented languages. We present a new type system, λ* , which enables expressive ownership-style reasoning across higher-order functions. It tracks sharing and separation through reachability sets, and layers additional mechanisms for selectively enforcing uniqueness on top of it. Based on reachability sets, we extend the type system with an expressive flow-sensitive effect system, which enables flavors of move semantics and ownership transfer. In addition, we present several case studies and extensions, including applications to capabilities for algebraic effects, one-shot continuations, and safe parallelization.

References

  1. Martín Abadi, Andrew Birrell, Tim Harris, and Michael Isard. 2008. Semantics of transactional memory and automatic mutual exclusion. In POPL. ACM, 63–74. https://doi.org/10.1145/1328438.1328449 Google ScholarGoogle ScholarDigital LibraryDigital Library
  2. Amal Ahmed, Matthew Fluet, and Greg Morrisett. 2007. L^ 3: A Linear Language with Locations. Fundam. Informaticae, 77, 4 (2007), 397–449. http://content.iospress.com/articles/fundamenta-informaticae/fi77-4-06 Google ScholarGoogle ScholarDigital LibraryDigital Library
  3. Alexander Aiken, Jeffrey S. Foster, John Kodumal, and Tachio Terauchi. 2003. Checking and inferring local non-aliasing. In PLDI. ACM, 129–140. https://doi.org/10.1145/781131.781146 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Jonathan Aldrich, Joshua Sunshine, Darpan Saini, and Zachary Sparks. 2009. Typestate-oriented programming. In OOPSLA Companion. ACM, 1015–1022. https://doi.org/10.1145/1639950.1640073 Google ScholarGoogle ScholarDigital LibraryDigital Library
  5. Nada Amin, Samuel Grütter, Martin Odersky, Tiark Rompf, and Sandro Stucki. 2016. The Essence of Dependent Object Types. In A List of Successes That Can Change the World (Lecture Notes in Computer Science, Vol. 9600). Springer, 249–272. https://doi.org/10.1007/978-3-319-30936-1_14 Google ScholarGoogle ScholarCross RefCross Ref
  6. Nada Amin and Tiark Rompf. 2017. Type soundness proofs with definitional interpreters. In POPL. ACM, 666–679. https://doi.org/10.1145/3009837.3009866 Google ScholarGoogle ScholarDigital LibraryDigital Library
  7. Hendrik Pieter Barendregt. 1985. The lambda calculus - its syntax and semantics (Studies in logic and the foundations of mathematics, Vol. 103). North-Holland.Google ScholarGoogle Scholar
  8. Erik Barendsen and Sjaak Smetsers. 1996. Uniqueness Typing for Functional Languages with Graph Rewriting Semantics. Math. Struct. Comput. Sci., 6, 6 (1996), 579–612. https://doi.org/10.1017/S0960129500070109 Google ScholarGoogle ScholarCross RefCross Ref
  9. Jean-Philippe Bernardy, Mathieu Boespflug, Ryan R. Newton, Simon Peyton Jones, and Arnaud Spiwack. 2018. Linear Haskell: practical linearity in a higher-order polymorphic language. Proc. ACM Program. Lang., 2, POPL (2018), 5:1–5:29. https://doi.org/10.1145/3158093 Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Dariusz Biernacki, Maciej Piróg, Piotr Polesiuk, and Filip Sieczkowski. 2019. Abstracting algebraic effects. Proc. ACM Program. Lang., 3, POPL (2019), 6:1–6:28. https://doi.org/10.1145/3290319 Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Dariusz Biernacki, Maciej Piróg, Piotr Polesiuk, and Filip Sieczkowski. 2020. Binders by day, labels by night: effect instances via lexically scoped handlers. Proc. ACM Program. Lang., 4, POPL (2020), 48:1–48:29. https://doi.org/10.1145/3371116 Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Aleksander Boruch-Gruszecki, Jonathan Immanuel Brachthäuser, Edward Lee, Ondřej Lhoták, and Martin Odersky. 2021. Tracking Captured Variables in Types. May, technical report. arxiv:2105.11896 (v1). arxiv:2105.11896Google ScholarGoogle Scholar
  13. Chandrasekhar Boyapati, Robert Lee, and Martin C. Rinard. 2002. Ownership types for safe programming: preventing data races and deadlocks. In OOPSLA. ACM, 211–230. https://doi.org/10.1145/582419.582440 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. John Boyland. 2003. Checking Interference with Fractional Permissions. In SAS (Lecture Notes in Computer Science, Vol. 2694). Springer, 55–72. https://doi.org/10.1007/3-540-44898-5_4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  15. John Boyland, James Noble, and William Retert. 2001. Capabilities for Sharing: A Generalisation of Uniqueness and Read-Only. In ECOOP (Lecture Notes in Computer Science, Vol. 2072). Springer, 2–27. https://doi.org/10.1007/3-540-45337-7_2 Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Jonathan Immanuel Brachthäuser, Philipp Schuster, and Klaus Ostermann. 2020. Effects as capabilities: effect handlers and lightweight effect polymorphism. Proc. ACM Program. Lang., 4, OOPSLA (2020), 126:1–126:30. https://doi.org/10.1145/3428194 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Jonathan Immanuel Brachthäuser, Philipp Schuster, and Klaus Ostermann. 2020. Effekt: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala. J. Funct. Program., 30 (2020), e8. https://doi.org/10.1017/S0956796820000027 Google ScholarGoogle ScholarCross RefCross Ref
  18. Walter Bright. 2019. Ownership and Borrowing in D. https://web.archive.org/web/20210105083139/https://dlang.org/blog/2019/07/15/ownership-and-borrowing-in-d/ Accessed: 2021-01-05Google ScholarGoogle Scholar
  19. Carl Bruggeman, Oscar Waddell, and R. Kent Dybvig. 1996. Representing Control in the Presence of One-Shot Continuations. In PLDI. ACM, 99–107. https://doi.org/10.1145/231379.231395 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Luca Cardelli, Simone Martini, John C. Mitchell, and Andre Scedrov. 1991. An Extension of System F with Subtyping. In TACS (Lecture Notes in Computer Science, Vol. 526). Springer, 750–770. https://doi.org/10.1007/3-540-54415-1_73 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Elias Castegren and Tobias Wrigstad. 2016. Reference Capabilities for Concurrency Control. In ECOOP (LIPIcs, Vol. 56). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 5:1–5:26. https://doi.org/10.4230/LIPIcs.ECOOP.2016.5 Google ScholarGoogle ScholarCross RefCross Ref
  22. Arthur Charguéraud. 2020. Separation logic for sequential programs (functional pearl). Proc. ACM Program. Lang., 4, ICFP (2020), 116:1–116:34. https://doi.org/10.1145/3408998 Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. 2017. Chez Scheme Version 9 User’s Guide - Chapter 6. Control Structures. Available at https://cisco.github.io/ChezScheme/csug9.4/control.htmlGoogle ScholarGoogle Scholar
  24. Dave Clarke, Johan Östlund, Ilya Sergey, and Tobias Wrigstad. 2013. Ownership Types: A Survey. In Aliasing in Object-Oriented Programming (Lecture Notes in Computer Science, Vol. 7850). Springer, 15–58. https://doi.org/10.1007/978-3-642-36946-9_3 Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. Dave Clarke, Tobias Wrigstad, Johan Östlund, and Einar Broch Johnsen. 2008. Minimal Ownership for Active Objects. In APLAS (Lecture Notes in Computer Science, Vol. 5356). Springer, 139–154. https://doi.org/10.1007/978-3-540-89330-1_11 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. David G. Clarke and Sophia Drossopoulou. 2002. Ownership, encapsulation and the disjointness of type and effect. In OOPSLA. ACM, 292–310. https://doi.org/10.1145/582419.582447 Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. David G. Clarke, James Noble, and John Potter. 2001. Simple Ownership Types for Object Containment. In ECOOP (Lecture Notes in Computer Science, Vol. 2072). Springer, 53–76. https://doi.org/10.1007/3-540-45337-7_4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. David G. Clarke, John Potter, and James Noble. 1998. Ownership Types for Flexible Alias Protection. In OOPSLA. ACM, 48–64. https://doi.org/10.1145/286936.286947 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Sylvan Clebsch, Sebastian Blessing, Juliana Franco, and Sophia Drossopoulou. 2015. Ownership and reference counting based garbage collection in the actor world. In ICOOOLPS’2015. ACM.Google ScholarGoogle Scholar
  30. Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil. 2015. Deny capabilities for safe, fast actors. In Proceedings of the 5th International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE! 2015). ACM, 1–12. https://doi.org/10.1145/2824815.2824816 Google ScholarGoogle ScholarDigital LibraryDigital Library
  31. Youyou Cong, Leo Osvald, Grégory M. Essertel, and Tiark Rompf. 2019. Compiling with continuations, or without? Whatever. Proc. ACM Program. Lang., 3, ICFP (2019), 79:1–79:28. https://doi.org/10.1145/3341643 Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Olivier Danvy and Andrzej Filinski. 1989. A Functional Abstraction of Typed Contexts. Technical Report, DIKU University of Copenhagen, Denmark.Google ScholarGoogle Scholar
  33. Olivier Danvy and Andrzej Filinski. 1990. Abstracting Control. In LISP and Functional Programming. ACM, 151–160. https://doi.org/10.1145/91556.91622 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Edsko de Vries, Rinus Plasmeijer, and David M. Abrahamson. 2006. Uniqueness Typing Redefined. In IFL (Lecture Notes in Computer Science, Vol. 4449). Springer, 181–198. https://doi.org/10.1007/978-3-540-74130-5_11 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Edsko de Vries, Rinus Plasmeijer, and David M. Abrahamson. 2007. Uniqueness Typing Simplified. In IFL (Lecture Notes in Computer Science, Vol. 5083). Springer, 201–218. https://doi.org/10.1007/978-3-540-85373-2_12 Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Robert DeLine and Manuel Fähndrich. 2001. Enforcing High-Level Protocols in Low-Level Software. In PLDI. ACM, 59–69. https://doi.org/10.1145/378795.378811 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Werner Dietl, Sophia Drossopoulou, and Peter Müller. 2011. Separating ownership topology and encapsulation with generic universe types. ACM Trans. Program. Lang. Syst., 33, 6 (2011), 20:1–20:62. https://doi.org/10.1145/2049706.2049709 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Bruce F. Duba, Robert Harper, and David B. MacQueen. 1991. Typing First-Class Continuations in ML. In POPL. ACM Press, 163–173. https://doi.org/10.1145/99583.99608 Google ScholarGoogle ScholarDigital LibraryDigital Library
  39. Matthias Felleisen. 1988. The Theory and Practice of First-Class Prompts. In POPL. ACM Press, 180–190. https://doi.org/10.1145/73560.73576 Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. David Gay and Alexander Aiken. 1998. Memory Management with Explicit Regions. In PLDI. ACM, 313–323. https://doi.org/10.1145/277650.277748 Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. David K. Gifford and John M. Lucassen. 1986. Integrating Functional and Imperative Programming. In LISP and Functional Programming. ACM, 28–38. https://doi.org/10.1145/319838.319848 Google ScholarGoogle ScholarDigital LibraryDigital Library
  42. Jean-Yves Girard. 1971. Une Extension De ĽInterpretation De Gödel a ĽAnalyse, Et Son Application a ĽElimination Des Coupures Dans ĽAnalyse Et La Theorie Des Types. In Proceedings of the Second Scandinavian Logic Symposium, J.E. Fenstad (Ed.) (Studies in Logic and the Foundations of Mathematics, Vol. 63). Elsevier, 63–92. issn:0049-237X https://doi.org/10.1016/S0049-237X(08)70843-7 Google ScholarGoogle ScholarCross RefCross Ref
  43. Colin S. Gordon. 2020. Designing with Static Capabilities and Effects: Use, Mention, and Invariants (Pearl). In ECOOP (LIPIcs, Vol. 166). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 10:1–10:25. https://doi.org/10.4230/LIPIcs.ECOOP.2020.10 Google ScholarGoogle ScholarCross RefCross Ref
  44. Colin S. Gordon. 2020. Lifting Sequential Effects to Control Operators. In ECOOP (LIPIcs, Vol. 166). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 23:1–23:30. https://doi.org/10.4230/LIPIcs.ECOOP.2020.23 Google ScholarGoogle ScholarCross RefCross Ref
  45. Colin S. Gordon. 2021. Polymorphic Iterable Sequential Effect Systems. ACM Trans. Program. Lang. Syst., 43, 1 (2021), 4:1–4:79. https://doi.org/10.1145/3450272 Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. Colin S. Gordon, Michael D. Ernst, and Dan Grossman. 2012. Static lock capabilities for deadlock freedom. In TLDI. ACM, 67–78. https://doi.org/10.1145/2103786.2103796 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Dan Grossman, J. Gregory Morrisett, Trevor Jim, Michael W. Hicks, Yanling Wang, and James Cheney. 2002. Region-Based Memory Management in Cyclone. In PLDI. ACM, 282–293. https://doi.org/10.1145/512529.512563 Google ScholarGoogle ScholarDigital LibraryDigital Library
  48. Philipp Haller and Alexander Loiko. 2016. LaCasa: lightweight affinity and object capabilities in Scala. In OOPSLA. ACM, 272–291. https://doi.org/10.1145/2983990.2984042 Google ScholarGoogle ScholarDigital LibraryDigital Library
  49. Philipp Haller and Martin Odersky. 2010. Capabilities for Uniqueness and Borrowing. In ECOOP (Lecture Notes in Computer Science, Vol. 6183). Springer, 354–378. https://doi.org/10.1007/978-3-642-14107-2_17 Google ScholarGoogle ScholarDigital LibraryDigital Library
  50. Daniel Hillerström and Sam Lindley. 2018. Shallow Effect Handlers. In APLAS (Lecture Notes in Computer Science, Vol. 11275). Springer, 415–435. https://doi.org/10.1007/978-3-030-02768-1_22 Google ScholarGoogle ScholarCross RefCross Ref
  51. Daniel Hillerström, Sam Lindley, and Robert Atkey. 2020. Effect handlers via generalised continuations. J. Funct. Program., 30 (2020), e5. https://doi.org/10.1017/S0956796820000040 Google ScholarGoogle ScholarCross RefCross Ref
  52. Daniel Hillerström, Sam Lindley, Robert Atkey, and K. C. Sivaramakrishnan. 2017. Continuation Passing Style for Effect Handlers. In FSCD (LIPIcs, Vol. 84). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 18:1–18:19. https://doi.org/10.4230/LIPIcs.FSCD.2017.18 Google ScholarGoogle ScholarCross RefCross Ref
  53. John Hogg. 1991. Islands: Aliasing Protection in Object-Oriented Languages. In OOPSLA. ACM, 271–285. https://doi.org/10.1145/117954.117975 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Samin S. Ishtiaq and Peter W. O’Hearn. 2001. BI as an Assertion Language for Mutable Data Structures. In POPL. ACM, 14–26. https://doi.org/10.1145/360204.375719 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Andrej Ivaskovic, Alan Mycroft, and Dominic Orchard. 2020. Data-Flow Analyses as Effects and Graded Monads. In FSCD (LIPIcs, Vol. 167). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 15:1–15:23. https://doi.org/10.4230/LIPIcs.FSCD.2020.15 Google ScholarGoogle ScholarCross RefCross Ref
  56. Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer. 2018. RustBelt: securing the foundations of the rust programming language. Proc. ACM Program. Lang., 2, POPL (2018), 66:1–66:34. https://doi.org/10.1145/3158154 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer. 2021. Safe systems programming in Rust. Commun. ACM, 64, 4 (2021), 144–152. https://doi.org/10.1145/3418295 Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Ralf Jung, Robbert Krebbers, Jacques-Henri Jourdan, Ales Bizjak, Lars Birkedal, and Derek Dreyer. 2018. Iris from the ground up: A modular foundation for higher-order concurrent separation logic. J. Funct. Program., 28 (2018), e20. https://doi.org/10.1017/S0956796818000151 Google ScholarGoogle ScholarCross RefCross Ref
  59. Ifaz Kabir, Yufeng Li, and Ondrej Lhoták. 2020. ι DOT: a DOT calculus with object initialization. Proc. ACM Program. Lang., 4, OOPSLA (2020), 208:1–208:28. https://doi.org/10.1145/3428276 Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in action. In ICFP. ACM, 145–158. https://doi.org/10.1145/2500365.2500590 Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Steve Klabnik and Carol Nichols. 2019. The Rust Programming Language. No Starch Press. Google ScholarGoogle ScholarDigital LibraryDigital Library
  62. Alexander Kogtenkov, Bertrand Meyer, and Sergey Velder. 2015. Alias calculus, change calculus and frame inference. Sci. Comput. Program., 97 (2015), 163–172. https://doi.org/10.1016/j.scico.2013.11.006 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Robbert Krebbers, Ralf Jung, Ales Bizjak, Jacques-Henri Jourdan, Derek Dreyer, and Lars Birkedal. 2017. The Essence of Higher-Order Concurrent Separation Logic. In ESOP (Lecture Notes in Computer Science, Vol. 10201). Springer, 696–723. https://doi.org/10.1007/978-3-662-54434-1_26 Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Neelakantan Krishnaswami. 2006. Separation logic for a higher-order typed language. In Workshop on Semantics, Program Analysis and Computing Environments for Memory Management, SPACE. 6, 73–82.Google ScholarGoogle Scholar
  65. Neelakantan R. Krishnaswami, Jonathan Aldrich, Lars Birkedal, Kasper Svendsen, and Alexandre Buisse. 2009. Design patterns in separation logic. In TLDI. ACM, 105–116. https://doi.org/10.1145/1481861.1481874 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Daan Leijen. 2017. Type directed compilation of row-typed algebraic effects. In POPL. ACM, 486–499. https://doi.org/10.1145/3009837.3009872 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Fengyun Liu, Ondrej Lhoták, Aggelos Biboudis, Paolo G. Giarrusso, and Martin Odersky. 2020. A type-and-effect system for object initialization. Proc. ACM Program. Lang., 4, OOPSLA (2020), 175:1–175:28. https://doi.org/10.1145/3428243 Google ScholarGoogle ScholarDigital LibraryDigital Library
  68. Yi Lu and John Potter. 2005. A Type System for Reachability and Acyclicity. In ECOOP (Lecture Notes in Computer Science, Vol. 3586). Springer, 479–503. https://doi.org/10.1007/11531142_21 Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. John M. Lucassen and David K. Gifford. 1988. Polymorphic Effect Systems. In POPL. ACM Press, 47–57. https://doi.org/10.1145/73560.73564 Google ScholarGoogle ScholarDigital LibraryDigital Library
  70. Nicholas D. Matsakis and Felix S. II Klock. 2014. The Rust language. In HILT. ACM, 103–104. https://doi.org/10.1145/2663171.2663188 Google ScholarGoogle ScholarDigital LibraryDigital Library
  71. Peter Müller and Arnd Poetzsch-Heffter. 2000. A type system for controlling representation exposure in Java. In ECOOP Workshop on Formal Techniques for Java Programs.Google ScholarGoogle Scholar
  72. Karl Naden, Robert Bocchino, Jonathan Aldrich, and Kevin Bierhoff. 2012. A type system for borrowing permissions. In POPL. ACM, 557–570. https://doi.org/10.1145/2103656.2103722 Google ScholarGoogle ScholarDigital LibraryDigital Library
  73. Flemming Nielson and Hanne Riis Nielson. 1999. Type and Effect Systems. In Correct System Design (Lecture Notes in Computer Science, Vol. 1710). Springer, 114–136. https://doi.org/10.1007/3-540-48092-7_6 Google ScholarGoogle ScholarDigital LibraryDigital Library
  74. James Noble. 2018. Two Decades of Ownership Types. In SPLASH-I. ACM.Google ScholarGoogle Scholar
  75. James Noble, Jan Vitek, and John Potter. 1998. Flexible Alias Protection. In ECOOP (Lecture Notes in Computer Science, Vol. 1445). Springer, 158–185. https://doi.org/10.1007/BFb0054091 Google ScholarGoogle ScholarDigital LibraryDigital Library
  76. Martin Odersky. 1991. How to Make Destructive Updates Less Destructive. In POPL. ACM Press, 25–36. https://doi.org/10.1145/99583.99590 Google ScholarGoogle ScholarDigital LibraryDigital Library
  77. Martin Odersky and Tiark Rompf. 2014. Unifying functional and object-oriented programming with Scala. Commun. ACM, 57, 4 (2014), 76–86. https://doi.org/10.1145/2591013 Google ScholarGoogle ScholarDigital LibraryDigital Library
  78. Peter W. O’Hearn. 2003. On bunched typing. J. Funct. Program., 13, 4 (2003), 747–796. https://doi.org/10.1017/S0956796802004495 Google ScholarGoogle ScholarDigital LibraryDigital Library
  79. Peter W. O’Hearn, John Power, Makoto Takeyama, and Robert D. Tennent. 1999. Syntactic Control of Interference Revisited. Theor. Comput. Sci., 228, 1-2 (1999), 211–252. https://doi.org/10.1016/S0304-3975(98)00359-4 Google ScholarGoogle ScholarDigital LibraryDigital Library
  80. Peter W. O’Hearn, John C. Reynolds, and Hongseok Yang. 2001. Local Reasoning about Programs that Alter Data Structures. In CSL (Lecture Notes in Computer Science, Vol. 2142). Springer, 1–19. https://doi.org/10.1007/3-540-44802-0_1 Google ScholarGoogle ScholarDigital LibraryDigital Library
  81. Leo Osvald, Grégory M. Essertel, Xilun Wu, Lilliam I. González Alayón, and Tiark Rompf. 2016. Gentrification gone too far? affordable 2nd-class values for fun and (co-)effect. In OOPSLA. ACM, 234–251. https://doi.org/10.1145/2983990.2984009 Google ScholarGoogle ScholarDigital LibraryDigital Library
  82. David J. Pearce. 2011. JPure: A Modular Purity System for Java. In CC (Lecture Notes in Computer Science, Vol. 6601). Springer, 104–123. https://doi.org/10.1007/978-3-642-19861-8_7 Google ScholarGoogle ScholarDigital LibraryDigital Library
  83. Benjamin C. Pierce. 2002. Types and programming languages. MIT Press. Google ScholarGoogle ScholarDigital LibraryDigital Library
  84. Gordon D. Plotkin and John Power. 2003. Algebraic Operations and Generic Effects. Appl. Categorical Struct., 11, 1 (2003), 69–94. https://doi.org/10.1023/A:1023064908962 Google ScholarGoogle ScholarCross RefCross Ref
  85. Gordon D. Plotkin and Matija Pretnar. 2009. Handlers of Algebraic Effects. In ESOP (Lecture Notes in Computer Science, Vol. 5502). Springer, 80–94. https://doi.org/10.1007/978-3-642-00590-9_7 Google ScholarGoogle ScholarDigital LibraryDigital Library
  86. Thomas W. Reps. 1997. Program Analysis via Graph Reachability. In ILPS. MIT Press, 5–19. Google ScholarGoogle ScholarDigital LibraryDigital Library
  87. Thomas W. Reps, Susan Horwitz, and Shmuel Sagiv. 1995. Precise Interprocedural Dataflow Analysis via Graph Reachability. In POPL. ACM Press, 49–61. https://doi.org/10.1145/199448.199462 Google ScholarGoogle ScholarDigital LibraryDigital Library
  88. John C. Reynolds. 1974. Towards a theory of type structure. In Symposium on Programming (Lecture Notes in Computer Science, Vol. 19). Springer, 408–423. https://doi.org/10.1007/3-540-06859-7_148 Google ScholarGoogle ScholarDigital LibraryDigital Library
  89. John C. Reynolds. 1978. Syntactic Control of Interference. In POPL. ACM Press, 39–46. https://doi.org/10.1145/512760.512766 Google ScholarGoogle ScholarDigital LibraryDigital Library
  90. John C. Reynolds. 1989. Syntactic Control of Inference, Part 2. In ICALP (Lecture Notes in Computer Science, Vol. 372). Springer, 704–722. https://doi.org/10.1007/BFb0035793 Google ScholarGoogle ScholarDigital LibraryDigital Library
  91. John C. Reynolds. 2002. Separation Logic: A Logic for Shared Mutable Data Structures. In LICS. IEEE Computer Society, 55–74. https://doi.org/10.1109/LICS.2002.1029817 Google ScholarGoogle ScholarDigital LibraryDigital Library
  92. Tiark Rompf and Nada Amin. 2016. Type soundness for dependent object types (DOT). In OOPSLA. ACM, 624–641. https://doi.org/10.1145/2983990.2984008 Google ScholarGoogle ScholarDigital LibraryDigital Library
  93. Tiark Rompf, Kevin J. Brown, HyoukJoong Lee, Arvind K. Sujeeth, Manohar Jonnalagedda, Nada Amin, Georg Ofenbeck, Alen Stojanov, Yannis Klonatos, Mohammad Dashti, Christoph Koch, Markus Püschel, and Kunle Olukotun. 2015. Go Meta! A Case for Generative Programming and DSLs in Performance Critical Systems. In SNAPL (LIPIcs, Vol. 32). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 238–261. https://doi.org/10.4230/LIPIcs.SNAPL.2015.238 Google ScholarGoogle ScholarCross RefCross Ref
  94. Tiark Rompf, Ingo Maier, and Martin Odersky. 2009. Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform. In ICFP. ACM, 317–328. https://doi.org/10.1145/1596550.1596596 Google ScholarGoogle ScholarDigital LibraryDigital Library
  95. Tiark Rompf and Martin Odersky. 2012. Lightweight modular staging: a pragmatic approach to runtime code generation and compiled DSLs. Commun. ACM, 55, 6 (2012), 121–130. https://doi.org/10.1145/2184319.2184345 Google ScholarGoogle ScholarDigital LibraryDigital Library
  96. Tiark Rompf, Arvind K. Sujeeth, Nada Amin, Kevin J. Brown, Vojin Jovanovic, HyoukJoong Lee, Manohar Jonnalagedda, Kunle Olukotun, and Martin Odersky. 2013. Optimizing data structures in high-level programs: new directions for extensible compilers based on staging. In POPL. ACM, 497–510. https://doi.org/10.1145/2429069.2429128 Google ScholarGoogle ScholarDigital LibraryDigital Library
  97. Gabriel Scherer and Jan Hoffmann. 2013. Tracking Data-Flow with Open Closure Types. In LPAR (Lecture Notes in Computer Science, Vol. 8312). Springer, 710–726. https://doi.org/10.1007/978-3-642-45221-5_47 Google ScholarGoogle ScholarCross RefCross Ref
  98. Philipp Schuster, Jonathan Immanuel Brachthäuser, and Klaus Ostermann. 2020. Compiling effect handlers in capability-passing style. Proc. ACM Program. Lang., 4, ICFP (2020), 93:1–93:28. https://doi.org/10.1145/3408975 Google ScholarGoogle ScholarDigital LibraryDigital Library
  99. K. C. Sivaramakrishnan, Stephen Dolan, Leo White, Tom Kelly, Sadiq Jaffer, and Anil Madhavapeddy. 2021. Retrofitting effect handlers onto OCaml. In PLDI. ACM, 206–221. https://doi.org/10.1145/3453483.3454039 Google ScholarGoogle ScholarDigital LibraryDigital Library
  100. Frederick Smith, David Walker, and J. Gregory Morrisett. 2000. Alias Types. In ESOP (Lecture Notes in Computer Science, Vol. 1782). Springer, 366–381. https://doi.org/10.1007/3-540-46425-5_24 Google ScholarGoogle ScholarDigital LibraryDigital Library
  101. George Steed and Sophia Drossopoulou. 2016. A principled design of capabilities in Pony. Master’s thesis, Imperial College.Google ScholarGoogle Scholar
  102. Alexander J. Summers and Peter Müller. 2011. Freedom before commitment: a lightweight type system for object initialisation. In OOPSLA. ACM, 1013–1032. https://doi.org/10.1145/2048066.2048142 Google ScholarGoogle ScholarDigital LibraryDigital Library
  103. The Swift Developer Community. 2019. Ownership Manifesto. https://github.com/apple/swift/blob/main/docs/OwnershipManifesto.md Accessed: 2021-04-09 (ae2a4cca14)Google ScholarGoogle Scholar
  104. Mads Tofte and Jean-Pierre Talpin. 1997. Region-based Memory Management. Inf. Comput., 132, 2 (1997), 109–176. https://doi.org/10.1006/inco.1996.2613 Google ScholarGoogle ScholarDigital LibraryDigital Library
  105. David N. Turner, Philip Wadler, and Christian Mossin. 1995. Once Upon a Type. In FPCA. ACM, 1–11. https://doi.org/10.1145/224164.224168 Google ScholarGoogle ScholarDigital LibraryDigital Library
  106. Dimitrios Vardoulakis and Olin Shivers. 2011. CFA2: a Context-Free Approach to Control-Flow Analysis. Log. Methods Comput. Sci., 7, 2 (2011), https://doi.org/10.2168/LMCS-7(2:3)2011 Google ScholarGoogle ScholarCross RefCross Ref
  107. Philip Wadler. 1990. Linear Types can Change the World!. In Programming Concepts and Methods. North-Holland, 561.Google ScholarGoogle Scholar
  108. David Walker, Karl Crary, and J. Gregory Morrisett. 2000. Typed memory management via static capabilities. ACM Trans. Program. Lang. Syst., 22, 4 (2000), 701–771. https://doi.org/10.1145/363911.363923 Google ScholarGoogle ScholarDigital LibraryDigital Library
  109. Andrew K. Wright and Matthias Felleisen. 1994. A Syntactic Approach to Type Soundness. Inf. Comput., 115, 1 (1994), 38–94. https://doi.org/10.1006/inco.1994.1093 Google ScholarGoogle ScholarDigital LibraryDigital Library
  110. Ningning Xie, Jonathan Immanuel Brachthäuser, Daniel Hillerström, Philipp Schuster, and Daan Leijen. 2020. Effect handlers, evidently. Proc. ACM Program. Lang., 4, ICFP (2020), 99:1–99:29. https://doi.org/10.1145/3408981 Google ScholarGoogle ScholarDigital LibraryDigital Library
  111. Hirotoshi Yasuoka and Tachio Terauchi. 2009. Polymorphic Fractional Capabilities. In SAS (Lecture Notes in Computer Science, Vol. 5673). Springer, 36–51. https://doi.org/10.1007/978-3-642-03237-0_5 Google ScholarGoogle ScholarDigital LibraryDigital Library
  112. Yizhou Zhang and Andrew C. Myers. 2019. Abstraction-safe effect handlers via tunneling. Proc. ACM Program. Lang., 3, POPL (2019), 5:1–5:29. https://doi.org/10.1145/3290318 Google ScholarGoogle ScholarDigital LibraryDigital Library
  113. Tian Zhao, Jason Baker, James Hunt, James Noble, and Jan Vitek. 2008. Implicit ownership types for memory management. Sci. Comput. Program., 71, 3 (2008), 213–241. https://doi.org/10.1016/j.scico.2008.04.001 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Reachability types: tracking aliasing and separation in higher-order functional programs

      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!