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.
Supplemental Material
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- Hendrik Pieter Barendregt. 1985. The lambda calculus - its syntax and semantics (Studies in logic and the foundations of mathematics, Vol. 103). North-Holland.Google Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 2017. Chez Scheme Version 9 User’s Guide - Chapter 6. Control Structures. Available at https://cisco.github.io/ChezScheme/csug9.4/control.htmlGoogle Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Olivier Danvy and Andrzej Filinski. 1989. A Functional Abstraction of Typed Contexts. Technical Report, DIKU University of Copenhagen, Denmark.Google Scholar
- Olivier Danvy and Andrzej Filinski. 1990. Abstracting Control. In LISP and Functional Programming. ACM, 151–160. https://doi.org/10.1145/91556.91622 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- David Gay and Alexander Aiken. 1998. Memory Management with Explicit Regions. In PLDI. ACM, 313–323. https://doi.org/10.1145/277650.277748 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- John Hogg. 1991. Islands: Aliasing Protection in Object-Oriented Languages. In OOPSLA. ACM, 271–285. https://doi.org/10.1145/117954.117975 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- Ohad Kammar, Sam Lindley, and Nicolas Oury. 2013. Handlers in action. In ICFP. ACM, 145–158. https://doi.org/10.1145/2500365.2500590 Google Scholar
Digital Library
- Steve Klabnik and Carol Nichols. 2019. The Rust Programming Language. No Starch Press. Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- Daan Leijen. 2017. Type directed compilation of row-typed algebraic effects. In POPL. ACM, 486–499. https://doi.org/10.1145/3009837.3009872 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- James Noble. 2018. Two Decades of Ownership Types. In SPLASH-I. ACM.Google Scholar
- 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 Scholar
Digital Library
- Martin Odersky. 1991. How to Make Destructive Updates Less Destructive. In POPL. ACM Press, 25–36. https://doi.org/10.1145/99583.99590 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- Peter W. O’Hearn. 2003. On bunched typing. J. Funct. Program., 13, 4 (2003), 747–796. https://doi.org/10.1017/S0956796802004495 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Benjamin C. Pierce. 2002. Types and programming languages. MIT Press. Google Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- Thomas W. Reps. 1997. Program Analysis via Graph Reachability. In ILPS. MIT Press, 5–19. Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- John C. Reynolds. 1978. Syntactic Control of Interference. In POPL. ACM Press, 39–46. https://doi.org/10.1145/512760.512766 Google Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- George Steed and Sophia Drossopoulou. 2016. A principled design of capabilities in Pony. Master’s thesis, Imperial College.Google Scholar
- 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 Scholar
Digital Library
- The Swift Developer Community. 2019. Ownership Manifesto. https://github.com/apple/swift/blob/main/docs/OwnershipManifesto.md Accessed: 2021-04-09 (ae2a4cca14)Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- Philip Wadler. 1990. Linear Types can Change the World!. In Programming Concepts and Methods. North-Holland, 561.Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
Index Terms
Reachability types: tracking aliasing and separation in higher-order functional programs
Recommendations
Recursive type generativity
Proceedings of the tenth ACM SIGPLAN international conference on Functional programmingExistential types provide a simple and elegant foundation for understanding generative abstract data types, of the kind supported by the Standard ML module system. However, in attempting to extend ML with support for recursive modules, we have found ...
Recursive type generativity
ICFP '05: Proceedings of the tenth ACM SIGPLAN international conference on Functional programmingExistential types provide a simple and elegant foundation for understanding generative abstract data types, of the kind supported by the Standard ML module system. However, in attempting to extend ML with support for recursive modules, we have found ...
Disjointness domains for fine-grained aliasing
OOPSLA 2015: Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and ApplicationsAliasing is crucial for supporting useful implementation patterns, but it makes reasoning about programs difficult. To deal with this problem, numerous type-based aliasing control mechanisms have been proposed, expressing properties such as uniqueness. ...






Comments