Nothing Special   »   [go: up one dir, main page]

skip to main content
research-article
Open access

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

Published: 15 October 2021 Publication History

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.

Supplementary Material

Auxiliary Presentation Video (oopsla21main-p181-p-video.mp4)
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
[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
[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
[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
[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
[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
[7]
Hendrik Pieter Barendregt. 1985. The lambda calculus - its syntax and semantics (Studies in logic and the foundations of mathematics, Vol. 103). North-Holland.
[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
[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
[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
[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
[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.11896
[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
[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
[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
[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
[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
[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-05
[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
[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
[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
[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
[23]
2017. Chez Scheme Version 9 User’s Guide - Chapter 6. Control Structures. Available at https://cisco.github.io/ChezScheme/csug9.4/control.html
[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
[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
[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
[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
[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
[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.
[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
[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
[32]
Olivier Danvy and Andrzej Filinski. 1989. A Functional Abstraction of Typed Contexts. Technical Report, DIKU University of Copenhagen, Denmark.
[33]
Olivier Danvy and Andrzej Filinski. 1990. Abstracting Control. In LISP and Functional Programming. ACM, 151–160. https://doi.org/10.1145/91556.91622
[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
[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
[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
[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
[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
[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
[40]
David Gay and Alexander Aiken. 1998. Memory Management with Explicit Regions. In PLDI. ACM, 313–323. https://doi.org/10.1145/277650.277748
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[53]
John Hogg. 1991. Islands: Aliasing Protection in Object-Oriented Languages. In OOPSLA. ACM, 271–285. https://doi.org/10.1145/117954.117975
[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
[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
[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
[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
[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
[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
[60]
Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in action. In ICFP. ACM, 145–158. https://doi.org/10.1145/2500365.2500590
[61]
Steve Klabnik and Carol Nichols. 2019. The Rust Programming Language. No Starch Press.
[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
[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
[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.
[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
[66]
Daan Leijen. 2017. Type directed compilation of row-typed algebraic effects. In POPL. ACM, 486–499. https://doi.org/10.1145/3009837.3009872
[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
[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
[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
[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
[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.
[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
[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
[74]
James Noble. 2018. Two Decades of Ownership Types. In SPLASH-I. ACM.
[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
[76]
Martin Odersky. 1991. How to Make Destructive Updates Less Destructive. In POPL. ACM Press, 25–36. https://doi.org/10.1145/99583.99590
[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
[78]
Peter W. O’Hearn. 2003. On bunched typing. J. Funct. Program., 13, 4 (2003), 747–796. https://doi.org/10.1017/S0956796802004495
[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
[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
[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
[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
[83]
Benjamin C. Pierce. 2002. Types and programming languages. MIT Press.
[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
[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
[86]
Thomas W. Reps. 1997. Program Analysis via Graph Reachability. In ILPS. MIT Press, 5–19.
[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
[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
[89]
John C. Reynolds. 1978. Syntactic Control of Interference. In POPL. ACM Press, 39–46. https://doi.org/10.1145/512760.512766
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[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
[101]
George Steed and Sophia Drossopoulou. 2016. A principled design of capabilities in Pony. Master’s thesis, Imperial College.
[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
[103]
The Swift Developer Community. 2019. Ownership Manifesto. https://github.com/apple/swift/blob/main/docs/OwnershipManifesto.md Accessed: 2021-04-09 (ae2a4cca14)
[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
[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
[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
[107]
Philip Wadler. 1990. Linear Types can Change the World!. In Programming Concepts and Methods. North-Holland, 561.
[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
[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
[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
[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
[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
[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

Cited By

View all
  • (2024)Degrees of Separation: A Flexible Type System for Safe ConcurrencyProceedings of the ACM on Programming Languages10.1145/36498538:OOPSLA1(1181-1207)Online publication date: 29-Apr-2024
  • (2024)Functional Ownership through Fractional UniquenessProceedings of the ACM on Programming Languages10.1145/36498488:OOPSLA1(1040-1070)Online publication date: 29-Apr-2024
  • (2024)Qualifying System F<:: Some Terms and Conditions May ApplyProceedings of the ACM on Programming Languages10.1145/36498328:OOPSLA1(583-612)Online publication date: 29-Apr-2024
  • Show More Cited By

Recommendations

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages
Proceedings of the ACM on Programming Languages  Volume 5, Issue OOPSLA
October 2021
2001 pages
EISSN:2475-1421
DOI:10.1145/3492349
Issue’s Table of Contents
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: 15 October 2021
Published in PACMPL Volume 5, Issue OOPSLA

Permissions

Request permissions for this article.

Check for updates

Author Tags

  1. aliasing
  2. effect systems
  3. ownership types
  4. reachability types
  5. type systems

Qualifiers

  • Research-article

Funding Sources

  • NSERC
  • DOE
  • NSF

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)343
  • Downloads (Last 6 weeks)85
Reflects downloads up to 12 Nov 2024

Other Metrics

Citations

Cited By

View all
  • (2024)Degrees of Separation: A Flexible Type System for Safe ConcurrencyProceedings of the ACM on Programming Languages10.1145/36498538:OOPSLA1(1181-1207)Online publication date: 29-Apr-2024
  • (2024)Functional Ownership through Fractional UniquenessProceedings of the ACM on Programming Languages10.1145/36498488:OOPSLA1(1040-1070)Online publication date: 29-Apr-2024
  • (2024)Qualifying System F<:: Some Terms and Conditions May ApplyProceedings of the ACM on Programming Languages10.1145/36498328:OOPSLA1(583-612)Online publication date: 29-Apr-2024
  • (2024)Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic ProgramsProceedings of the ACM on Programming Languages10.1145/36328568:POPL(393-424)Online publication date: 5-Jan-2024
  • (2023)Graph IRs for Impure Higher-Order Languages: Making Aggressive Optimizations Affordable with Precise Effect DependenciesProceedings of the ACM on Programming Languages10.1145/36228137:OOPSLA2(400-430)Online publication date: 16-Oct-2023
  • (2023)Capturing TypesACM Transactions on Programming Languages and Systems10.1145/361800345:4(1-52)Online publication date: 20-Nov-2023
  • (2023)Contextual Linear Types for Differential PrivacyACM Transactions on Programming Languages and Systems10.1145/358920745:2(1-69)Online publication date: 17-May-2023
  • (2023)Error Localization for Sequential Effect SystemsStatic Analysis10.1007/978-3-031-44245-2_16(343-370)Online publication date: 22-Oct-2023

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Get Access

Login options

Full Access

Media

Figures

Other

Tables

Share

Share

Share this Publication link

Share on social media