skip to main content
research-article
Public Access

Polymorphic Iterable Sequential Effect Systems

Published:17 April 2021Publication History
Skip Abstract Section

Abstract

Effect systems are lightweight extensions to type systems that can verify a wide range of important properties with modest developer burden. But our general understanding of effect systems is limited primarily to systems where the order of effects is irrelevant. Understanding such systems in terms of a semilattice of effects grounds understanding of the essential issues and provides guidance when designing new effect systems. By contrast, sequential effect systems—where the order of effects is important—lack an established algebraic structure on effects.

We present an abstract polymorphic effect system parameterized by an effect quantale—an algebraic structure with well-defined properties that can model the effects of a range of existing sequential effect systems. We define effect quantales, derive useful properties, and show how they cleanly model a variety of known sequential effect systems.

We show that for most effect quantales, there is an induced notion of iterating a sequential effect; that for systems we consider the derived iteration agrees with the manually designed iteration operators in prior work; and that this induced notion of iteration is as precise as possible when defined. We also position effect quantales with respect to work on categorical semantics for sequential effect systems, clarifying the distinctions between these systems and our own in the course of giving a thorough survey of these frameworks. Our derived iteration construct should generalize to these semantic structures, addressing limitations of that work. Finally, we consider the relationship between sequential effects and Kleene Algebras, where the latter may be used as instances of the former.

References

  1. Martin Abadi, Cormac Flanagan, and Stephen N. Freund. 2006. Types for safe locking: Static race detection for Java. ACM Trans. Program. Lang. Syst. 28, 2 (Mar. 2006), 207--255. DOI:DOI:https://doi.org/10.1145/1119479.1119480Google ScholarGoogle ScholarDigital LibraryDigital Library
  2. Andreas Abel. 2010. MiniAgda: Integrating sized and dependent types. In Partiality and Recursion in Theorem Proving. EPTCS. http://eptcs.web.cse.unsw.edu.au/content.cgi?PAR2010.Google ScholarGoogle Scholar
  3. Samson Abramsky and Steven Vickers. 1993. Quantales, observational logic and process semantics. Math. Struct. Comput. Sci. 3, 02 (1993), 161--227. DOI:DOI:https://doi.org/10.1017/S0960129500000189Google ScholarGoogle ScholarCross RefCross Ref
  4. Jorge Almeida, Stuart Margolis, Benjamin Steinberg, and Mikhail Volkov. 2009. Representation theory of finite semigroups, semigroup radicals and formal language theory. Trans. Amer. Math. Soc. 361, 3 (2009), 1429--1461.Google ScholarGoogle ScholarCross RefCross Ref
  5. Nada Amin, Adriaan Moors, and Martin Odersky. 2012. Dependent object types. In Proceedings of the 19th International Workshop on Foundations of Object-oriented Languages (FOOL’12).Google ScholarGoogle Scholar
  6. Torben Amtoft, Flemming Nielson, and Hanne Riis Nielson. 1999. Type and Effect Systems: Behaviours for Concurrency. Imperial College Press, London, UK.Google ScholarGoogle Scholar
  7. Davide Ancona, Viviana Bono, Mario Bravetti, Joana Campos, Giuseppe Castagna, Pierre-Malo Deniélou, Simon J. Gay, Nils Gesbert, Elena Giachino, Raymond Hu, Einar Broch Johnsen, Francisco Martins, Viviana Mascardi, Fabrizio Montesi, Rumyana Neykova, Nicholas Ng, Luca Padovani, Vasco T. Vasconcelos, and Nobuko Yoshida. 2016. Behavioral types in programming languages. Found. Trends Program. Lang. 3, 2-3 (2016), 95--230. DOI:DOI:https://doi.org/10.1561/2500000031Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. David Aspinall. 1994. Subtyping with singleton types. In Proceedings of the International Workshop on Computer Science Logic. Springer, 1--15.Google ScholarGoogle Scholar
  9. Robert Atkey. 2009. Parameterised notions of computation. J. Funct. Program. 19 (July 2009), 335--376.Google ScholarGoogle Scholar
  10. Robert Atkey and Conor McBride. 2013. Productive coprogramming with guarded recursion. In Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming. 197--208.Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Felipe Bañados Schwerter, Ronald Garcia, and Éric Tanter. 2014. A theory of gradual effect systems. In Proceedings of the 19th ACM SIGPLAN International Conference on Functional Programming (ICFP’14). ACM, 283--295. DOI:DOI:https://doi.org/10.1145/2628136.2628149Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Gilles Barthe, Benjamin Grégoire, and Colin Riba. 2008. Type-based termination with sized products. In Proceedings of the International Workshop on Computer Science Logic. Springer, 493--507.Google ScholarGoogle ScholarDigital LibraryDigital Library
  13. Nick Benton and Peter Buchlovsky. 2007. Semantics of an effect analysis for exceptions. In Proceedings of the ACM SIGPLAN International Workshop on Types in Languages Design and Implementation. DOI:DOI:https://doi.org/10.1145/1190315.1190320Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. Lars Birkedal and Rasmus Ejlers Møgelberg. 2013. Intensional type theory with guarded recursive types qua fixed points on universes. In Proceedings of the 28th IEEE/ACM Symposium on Logic in Computer Science (LICS’13). IEEE, 213--222. DOI:DOI:https://doi.org/10.1109/LICS.2013.27Google ScholarGoogle ScholarDigital LibraryDigital Library
  15. Lars Birkedal and Mads Tofte. 2001. A constraint-based region inference algorithm. Theoret. Comput. Sci. 258, 1 (2001), 299--392. DOI:DOI:https://doi.org/10.1016/S0304-3975(00)00025-6Google ScholarGoogle ScholarDigital LibraryDigital Library
  16. Lars Birkedal, Mads Tofte, and Magnus Vejlstrup. 1996. From region inference to Von Neumann machines via region representation inference. In Proceedings of the 23rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’96). 171--183. DOI:DOI:https://doi.org/10.1145/237721.237771Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Garrett Birkhoff. 1940. Lattice Theory (3rd ed.). Colloquium Publications, Vol. 25. American Mathematical Society.Google ScholarGoogle Scholar
  18. Thomas Scott Blyth. 2006. Lattices and Ordered Algebraic Structures. Springer Science & Business Media. DOI:DOI:https://doi.org/10.1007/b139095Google ScholarGoogle Scholar
  19. Robert L. Bocchino, Jr., Vikram S. Adve, Danny Dig, Sarita V. Adve, Stephen Heumann, Rakesh Komuravelli, Jeffrey Overbey, Patrick Simmons, Hyojin Sung, and Mohsen Vakilian. 2009. A type and effect system for deterministic parallel Java. In Proceedings of the ACM Conference on Object-oriented Programming, Systems, Languages, and Applications. DOI:DOI:https://doi.org/10.1145/1640089.1640097Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Chandrasekhar Boyapati, Robert Lee, and Martin Rinard. 2002. Ownership types for safe programming: Preventing data races and deadlocks. In Proceedings of the ACM Conference on Object-oriented Programming, Systems, Languages, and Applications. DOI:DOI:https://doi.org/10.1145/582419.582440Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Chandrasekhar Boyapati and Martin Rinard. 2001. A parameterized type system for race-free Java programs. In Proceedings of the ACM Conference on Object-oriented Programming, Systems, Languages, and Applications. DOI:DOI:https://doi.org/10.1145/504282.504287Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Cristiano Calcagno, Dino Distefano, Peter W. O’hearn, and Hongseok Yang. 2011. Compositional shape analysis by means of bi-abduction. J. ACM 58, 6 (2011), 1--66.Google ScholarGoogle ScholarDigital LibraryDigital Library
  23. Cristiano Calcagno, Peter W. O’Hearn, and Hongseok Yang. 2007. Local action and abstract separation logic. In Proceedings of the 22nd IEEE Symposium on Logic in Computer Science (LICS’07). IEEE, 366--378.Google ScholarGoogle ScholarDigital LibraryDigital Library
  24. Satish Chandra, Colin S. Gordon, Jean-Baptiste Jeannin, Cole Schlesinger, Manu Sridharan, Frank Tip, and Young-Il Choi. 2016. Type inference for static compilation of JavaScript. In Proceedings of the ACM Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA’16). DOI:DOI:https://doi.org/10.1145/2983990.2984017Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. Alfred Hoblitzelle Clifford and Gordon Bamford Preston. 1961. The Algebraic Theory of Semigroups, Volume I. American Mathematical Society.Google ScholarGoogle Scholar
  26. Ernie Cohen. 2000. Separation and reduction. In Proceedings of the International Conference on Mathematics of Program Construction. Springer, 45--59.Google ScholarGoogle ScholarCross RefCross Ref
  27. Karl Crary, David Walker, and Greg Morrisett. 1999. Typed memory management in a calculus of capabilities. In Proceedings of the 26th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM, 262--275. DOI:DOI:https://doi.org/10.1145/292540.292564Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Luis Damas and Robin Milner. 1982. Principal type-schemes for functional programs. In Proceedings of the 9th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’82). ACM, 207--212. DOI:DOI:https://doi.org/10.1145/582153.582176Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Benjamin Delaware, Bruno C. d. S. Oliveira, and Tom Schrijvers. 2013a. Meta-theory à La Carte. In Proceedings of the 40th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’13). ACM, 207--218. DOI:DOI:https://doi.org/10.1145/2429069.2429094Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Benjamin Delaware, Steven Keuchel, Tom Schrijvers, and Bruno C. d. S. Oliveira. 2013b. Modular monadic meta-theory. In Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming (ICFP’13). ACM, 319--330. DOI:DOI:https://doi.org/10.1145/2500365.2500587Google ScholarGoogle Scholar
  31. Mike Dodds, Xinyu Feng, Matthew Parkinson, and Viktor Vafeiadis. 2009. Deny-guarantee reasoning. In Proceedings of the 18th European Symposium on Programming (ESOP’09). Springer Berlin, 363--377. DOI:DOI:https://doi.org/10.1007/978-3-642-00590-9_26Google ScholarGoogle ScholarDigital LibraryDigital Library
  32. Zoltán Ésik, Uli Fahrenberg, and Axel Legay. 2015. *-Continuous Kleene -Algebras. In Proceedings of the International Conference on Developments in Language Theory. Springer, 240--251.Google ScholarGoogle Scholar
  33. Manuel Fähndrich, Mark Aiken, Chris Hawblitzel, Orion Hodson, Galen Hunt, James R. Larus, and Steven Levi. 2006. Language support for fast and reliable message-based communication in singularity OS. In Proceedings of the 1st ACM SIGOPS/EuroSys European Conference on Computer Systems (EuroSys’06). ACM, 177--190. DOI:DOI:https://doi.org/10.1145/1217935.1217953Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Andrzej Filinski. 1999. Representing layered monads. In Proceedings of the ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages.Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Andrzej Filinski. 2010. Monads in action. In Proceedings of the ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages.Google ScholarGoogle ScholarDigital LibraryDigital Library
  36. Cormac Flanagan and Martín Abadi. 1999b. Object types against races. In Proceedings of the International Conference on Concurrency Theory. DOI:DOI:https://doi.org/10.1007/3-540-48320-9_21Google ScholarGoogle ScholarCross RefCross Ref
  37. Cormac Flanagan and Martín Abadi. 1999a. Types for safe locking. In Proceedings of the European Symposium on Programming Languages and Systems. DOI:DOI:https://doi.org/10.1007/3-540-49099-X_7Google ScholarGoogle ScholarCross RefCross Ref
  38. Cormac Flanagan and Stephen N. Freund. 2000. Type-based race detection for Java. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation. DOI:DOI:https://doi.org/10.1145/349299.349328Google ScholarGoogle Scholar
  39. Cormac Flanagan and Shaz Qadeer. 2003a. A type and effect system for atomicity. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’03). ACM, 338--349. DOI:DOI:https://doi.org/10.1145/781131.781169Google ScholarGoogle ScholarDigital LibraryDigital Library
  40. Cormac Flanagan and Shaz Qadeer. 2003b. Types for atomicity. In Proceedings of the ACM SIGPLAN International Workshop on Types in Languages Design and Implementation (TLDI’03). ACM, 1--12. DOI:DOI:https://doi.org/10.1145/604174.604176Google ScholarGoogle ScholarDigital LibraryDigital Library
  41. Laszlo Fuchs. 2011. Partially Ordered Algebraic Systems. International Series of Monographs on Pure and Applied Mathematics, Vol. 28. Dover Publications.Google ScholarGoogle Scholar
  42. Soichiro Fujii, Shin-ya Katsumata, and Paul-André Mellies. 2016. Towards a formal theory of graded monads. In Proceedings of the International Conference on Foundations of Software Science and Computation Structures. Springer, 513--530.Google ScholarGoogle ScholarCross RefCross Ref
  43. Marco Gaboardi, Shin-ya Katsumata, Dominic Orchard, Flavien Breuvart, and Tarmo Uustalu. 2016. Combining effects and coeffects via grading. ACM SIGPLAN Not. 51, 9 (2016), 476--489.Google ScholarGoogle ScholarDigital LibraryDigital Library
  44. Nikolaos Galatos, Peter Jipsen, Tomasz Kowalski, and Hiroakira Ono. 2007. Residuated Lattices: An Algebraic Glimpse at Substructural Logics. Studies in Logic and the Foundations of Mathematics, Vol. 151. Elsevier.Google ScholarGoogle Scholar
  45. Ronald Garcia, Éric Tanter, Roger Wolff, and Jonathan Aldrich. 2014. Foundations of typestate-oriented programming. ACM Trans. Program. Lang. Syst. 36, 4 (Oct. 2014). DOI:DOI:https://doi.org/10.1145/2629609Google ScholarGoogle ScholarDigital LibraryDigital Library
  46. David K. Gifford and John M. Lucassen. 1986. Integrating functional and imperative programming. In Proceedings of the ACM Conference on LISP and Functional Programming (LFP’86). DOI:DOI:https://doi.org/10.1145/319838.319848Google ScholarGoogle Scholar
  47. Colin S. Gordon. 2017. A generic approach to flow-sensitive polymorphic effects. In Proceedings of the European Conference on Object-oriented Programming (ECOOP’17).Google ScholarGoogle Scholar
  48. Colin S. Gordon. 2020. Lifting sequential effects to control operators. In Proceedings of the 34th European Conference on Object-oriented Programming (ECOOP’20). Berlin, Germany.Google ScholarGoogle Scholar
  49. Colin S. Gordon, Werner Dietl, Michael D. Ernst, and Dan Grossman. 2013. JavaUI: Effects for controlling UI object access. In Proceedings of the European Conference on Object-oriented Programming (ECOOP’13).Google ScholarGoogle Scholar
  50. Colin S. Gordon, Michael D. Ernst, and Dan Grossman. 2012. Static lock capabilities for deadlock freedom. In Proceedings of the ACM SIGPLAN International Workshop on Types in Languages Design and Implementation.Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. James Gosling, Bill Joy, Guy L. Steele, Gilad Bracha, and Alex Buckley. 2014. The Java Language Specification: Java SE 8 Edition. Pearson Education.Google ScholarGoogle Scholar
  52. David Gregg. 2001. Comparing tail duplication with compensation code in single path global instruction scheduling. In Proceedings of the International Conference on Compiler Construction. Springer, 200--212.Google ScholarGoogle ScholarCross RefCross Ref
  53. Dan Grossman, Greg Morrisett, Trevor Jim, Michael Hicks, Yanling Wang, and James Cheney. 2002. Region-based memory management in Cyclone. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’02). ACM, 282--293. DOI:DOI:https://doi.org/10.1145/512529.512563Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Dan Grove and Linda Torczon. 1993. Interprocedural constant propagation: A study of jump function implementation. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’93). Association for Computing Machinery, New York, NY, 90--99. DOI:DOI:https://doi.org/10.1145/155090.155099Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Fritz Henglein, Henning Makholm, and Henning Niss. 2005. Effect types and region-based memory management. In Advanced Topics in Types and Programming Languages, Benjamin C. Pierce (Ed.). The MIT Press, 87--136.Google ScholarGoogle Scholar
  56. Kohei Honda, Nobuko Yoshida, and Marco Carbone. 2008. Multiparty asynchronous session types. In Proceedings of the 35th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’08). DOI:DOI:https://doi.org/10.1145/1328438.1328472Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Galen Hunt, Mark Aiken, Manuel Fähndrich, Chris Hawblitzel, Orion Hodson, James Larus, Steven Levi, Bjarne Steensgaard, David Tarditi, and Ted Wobber. 2007. Sealing OS processes to improve dependability and safety. In Proceedings of the 2nd ACM SIGOPS/EuroSys European Conference on Computer Systems (EuroSys’07). ACM, 341--354. DOI:DOI:https://doi.org/10.1145/1272996.1273032Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Galen C. Hunt and James R. Larus. 2007. Singularity: Rethinking the software stack. SIGOPS Oper. Syst. Rev. 41, 2 (Apr. 2007), 37--49. DOI:DOI:https://doi.org/10.1145/1243418.1243424Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Atsushi Igarashi and Naoki Kobayashi. 2002. Resource usage analysis. In Proceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 331--342.Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Andrej Ivašković, Alan Mycroft, and Dominic Orchard. 2020. Data-flow analyses as effects and graded monads. In Proceedings of the 5th International Conference on Formal Structures for Computation and Deduction (FSCD’20) (Leibniz International Proceedings in Informatics (LIPIcs)), Zena M. Ariola (Ed.), Vol. 167. Schloss Dagstuhl–Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 15:1–15:23. DOI:DOI:https://doi.org/10.4230/LIPIcs.FSCD.2020.15Google ScholarGoogle Scholar
  61. Mark P. Jones, J. Garrett Morris, and Richard A. Eisenberg. 2019. Partial type constructors: Or, making ad hoc datatypes less ad hoc. Proc. ACM Program. Lang. 4, POPL (Dec. 2019). DOI:DOI:https://doi.org/10.1145/3371108Google ScholarGoogle Scholar
  62. Shin-ya Katsumata. 2014. Parametric effect monads and semantics of effect systems. In Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’14). ACM, 633--645. DOI:DOI:https://doi.org/10.1145/2535838.2535846Google ScholarGoogle Scholar
  63. Ming Kawaguchi, Patrick Rondon, Alexander Bakst, and Ranjit Jhala. 2012. Deterministic parallelism via liquid effects. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation. DOI:DOI:https://doi.org/10.1145/2254064.2254071Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Eric Koskinen and Tachio Terauchi. 2014. Local temporal reasoning. In Proceedings of the Joint Meeting of the 23rd EACSL Conference on Computer Science Logic and the 29th ACM/IEEE Symposium on Logic in Computer Science (CSL-LICS’14). ACM, New York, NY. DOI:DOI:https://doi.org/10.1145/2603088.2603138Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. D. Kozen. 1994. A completeness theorem for Kleene algebras and the algebra of regular events. Inf. Comput. 110, 2 (1994), 366--390. DOI:DOI:https://doi.org/10.1006/inco.1994.1037Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. Dexter Kozen. 1997. Kleene algebra with tests. ACM Trans. Program. Lang. Syst. 19, 3 (1997), 427--443. DOI:DOI:https://doi.org/10.1145/256167.256195Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. Michael R. Laurence and Georg Struth. 2011. Omega algebras and regular equations. In Proceedings of the International Conference on Relational and Algebraic Methods in Computer Science. Springer, 248--263.Google ScholarGoogle Scholar
  68. Richard J. Lipton. 1975. Reduction: A method of proving properties of parallel programs. Commun. ACM 18, 12 (Dec. 1975), 717--721. DOI:DOI:https://doi.org/10.1145/361227.361234Google ScholarGoogle ScholarDigital LibraryDigital Library
  69. J. M. Lucassen and D. K. Gifford. 1988. Polymorphic effect systems. In Proceedings of the 15th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’88). DOI:DOI:https://doi.org/10.1145/73560.73564Google ScholarGoogle Scholar
  70. Bertrand A. Maher, Aaron Smith, Doug Burger, and Kathryn S. McKinley. 2006. Merging head and tail duplication for convergent hyperblock formation. In Proceedings of the 39th IEEE/ACM International Symposium on Microarchitecture (MICRO’06). IEEE, 65--76.Google ScholarGoogle Scholar
  71. Daniel Marino and Todd Millstein. 2009. A generic type-and-effect system. In Proceedings of the ACM SIGPLAN International Workshop on Types in Languages Design and Implementation. DOI:DOI:https://doi.org/10.1145/1481861.1481868Google ScholarGoogle Scholar
  72. Rasmus Ejlers Møgelberg. 2014. A type theory for productive coprogramming via guarded recursion. In Proceedings of the Joint Meeting of the 23rd EACSL Conference on Computer Science Logic (CSL’14) and the 29th ACM/IEEE Symposium on Logic in Computer Science (LICS’14). 1--10.Google ScholarGoogle ScholarDigital LibraryDigital Library
  73. Eliakim Hastings Moore. 1902. A definition of abstract groups. Trans. Amer. Math. Soc. 3, 4 (1902), 485--492.Google ScholarGoogle ScholarCross RefCross Ref
  74. Christopher J. Mulvey. 1986. Suppl. Rend. Circ. Mat. Palermo (2) 12 (1986), 99--104.Google ScholarGoogle Scholar
  75. Christopher J. Mulvey and Joan W. Pelletier. 1992. A quantisation of the calculus of relations. In Proceedings of the Canadian Mathematical Society Conference. 345--360.Google ScholarGoogle Scholar
  76. Alan Mycroft, Dominic Orchard, and Tomas Petricek. 2016. Effect systems revisited—Control-flow algebra and semantics. In Semantics, Logics, and Calculi. Springer, 1--32. DOI:DOI:https://doi.org/10.1007/978-3-319-27810-0_1Google ScholarGoogle Scholar
  77. Flemming Nielson and Hanne Riis Nielson. 1993. From CML to process algebras. In Proceedings of the International Conference on Concurrency Theory (CONCUR’93). Springer, 493--508. DOI:DOI:https://doi.org/10.1007/3-540-57208-2_34Google ScholarGoogle ScholarCross RefCross Ref
  78. Martin Odersky, Martin Sulzmann, and Martin Wehr. 1999. Type inference with constrained types. Theor. Pract. Obj. Syst. 5, 1 (1999), 35.Google ScholarGoogle ScholarDigital LibraryDigital Library
  79. Dominic Orchard and Nobuko Yoshida. 2016. Effects as sessions, sessions as effects. In Proceedings of the 43rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 568--581.Google ScholarGoogle ScholarDigital LibraryDigital Library
  80. Pierre-Marie Pédrot and Nicolas Tabareau. 2019. The fire triangle: How to mix substitution, dependent elimination, and effects. Proc. ACM Program. Lang. 4, POPL (2019), 58.Google ScholarGoogle Scholar
  81. François Pottier. 1998. A framework for type inference with subtyping. In Proceedings of the 3rd ACM SIGPLAN International Conference on Functional Programming (ICFP’98). 228--238. DOI:DOI:https://doi.org/10.1145/291251.289448Google ScholarGoogle ScholarDigital LibraryDigital Library
  82. Vaughan Pratt. 1990. Action logic and pure induction. In Proceedings of the European Workshop on Logics in Artificial Intelligence. Springer, 97--120. DOI:DOI:https://doi.org/10.1007/BFb0018436Google ScholarGoogle Scholar
  83. Thomas Reps, Susan Horwitz, and Mooly Sagiv. 1995. Precise interprocedural dataflow analysis via graph reachability. In Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. 49--61.Google ScholarGoogle ScholarDigital LibraryDigital Library
  84. Michael Rock and Andreas Koch. 2004. Architecture-independent meta-optimization by aggressive tail splitting. In Proceedings of the European Conference on Parallel Processing. Springer, 328--335.Google ScholarGoogle ScholarCross RefCross Ref
  85. Tiark Rompf and Nada Amin. 2016. Type soundness for dependent object types (DOT). In Proceedings of the ACM SIGPLAN International Conference on Object-oriented Programming, Systems, Languages, and Applications. 624--641.Google ScholarGoogle ScholarDigital LibraryDigital Library
  86. Lukas Rytz and Martin Odersky. 2012. Relative Effect Declarations for Lightweight Effect-Polymorphism. Technical Report EPFL-REPORT-175546. EPFL.Google ScholarGoogle Scholar
  87. Lukas Rytz, Martin Odersky, and Philipp Haller. 2012. Lightweight polymorphic effects. In Proceedings of the European Conference on Object-oriented Programming (ECOOP’12). DOI:DOI:https://doi.org/10.1007/978-3-642-31057-7_13Google ScholarGoogle ScholarDigital LibraryDigital Library
  88. Mooly Sagiv, Thomas Reps, and Susan Horwitz. 1996. Precise interprocedural dataflow analysis with applications to constant propagation. Theoret. Comput. Sci. 167, 1-2 (1996), 131--170.Google ScholarGoogle ScholarDigital LibraryDigital Library
  89. Vijay A. Saraswat, Martin Rinard, and Prakash Panangaden. 1991. The semantic foundations of concurrent constraint programming. In Proceedings of the 18th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’91). ACM, 333--352. DOI:DOI:https://doi.org/10.1145/99583.99627Google ScholarGoogle ScholarDigital LibraryDigital Library
  90. Christian Skalka. 2008. Types and trace effects for object orientation. High.-ord. Symb. Comput. 21, 3 (2008), 239--282. DOI:DOI:https://doi.org/10.1007/s10990-008-9032-6Google ScholarGoogle ScholarDigital LibraryDigital Library
  91. Christian Skalka, David Darais, Trent Jaeger, and Frank Capobianco. 2020. Types and abstract interpretation for authorization hook advice. In Proceedings of the IEEE 33rd Computer Security Foundations Symposium (CSF’20). IEEE, 139--152.Google ScholarGoogle ScholarCross RefCross Ref
  92. Christian Skalka, Scott Smith, and David Van Horn. 2008. Types and trace effects of higher order programs. J. Funct. Program. 18, 2 (2008).Google ScholarGoogle ScholarDigital LibraryDigital Library
  93. A. L. Smirnov. 2008. Graded monads and rings of polynomials. J. Math. Sci. 151, 3 (2008), 3032--3051.Google ScholarGoogle Scholar
  94. Kohei Suenaga. 2008. Type-based deadlock-freedom verification for non-block-structured lock primitives and mutable references. In Proceedings of the Asian Symposium on Programming Languages and Systems. Springer, 155--170. DOI:DOI:https://doi.org/10.1007/978-3-540-89330-1_12Google ScholarGoogle ScholarDigital LibraryDigital Library
  95. Joshua Sunshine, Karl Naden, Sven Stork, Jonathan Aldrich, and Éric Tanter. 2011. First-class state change in plaid. In Proceedings of the ACM International Conference on Object-oriented Programming Systems Languages and Applications (OOPSLA’11). ACM, New York, NY, 713--732. DOI:DOI:https://doi.org/10.1145/2048066.2048122Google ScholarGoogle ScholarDigital LibraryDigital Library
  96. Nikhil Swamy, Juan Chen, Cédric Fournet, Pierre-Yves Strub, Karthikeyan Bhargavan, and Jean Yang. 2011. Secure distributed programming with value-dependent types. In Proceedings of the 16th ACM SIGPLAN International Conference on Functional Programming. 266--278.Google ScholarGoogle ScholarDigital LibraryDigital Library
  97. Jean-Pierre Talpin and Pierre Jouvelot. 1992. Polymorphic type, region and effect inference. J. Funct. Program. 2, 03 (1992), 245--271. DOI:DOI:https://doi.org/10.1017/S0956796800000393Google ScholarGoogle ScholarCross RefCross Ref
  98. Ross Tate. 2013. The sequential semantics of producer effect systems. In Proceedings of the 40th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM. DOI:DOI:https://doi.org/10.1145/2429069.2429074Google ScholarGoogle ScholarDigital LibraryDigital Library
  99. Mads Tofte and Lars Birkedal. 1998. A region inference algorithm. ACM Trans. Program. Lang. Syst. 20, 4 (July 1998), 724--767.Google ScholarGoogle ScholarDigital LibraryDigital Library
  100. Mads Tofte and Jean-Pierre Talpin. 1994. Implementation of the typed call-by-value -calculus using a stack of regions. In Proceedings of the 21st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’94). 188--201. DOI:DOI:https://doi.org/10.1145/174675.177855Google ScholarGoogle ScholarDigital LibraryDigital Library
  101. Mads Tofte and Jean-Pierre Talpin. 1997. Region-based memory management. Inf. Comput. 132, 2 (1997), 109--176.Google ScholarGoogle ScholarDigital LibraryDigital Library
  102. Matías Toro and Éric Tanter. 2015. Customizable gradual polymorphic effects for Scala. In Proceedings of the ACM SIGPLAN International Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA’15). ACM, 935--953. DOI:DOI:https://doi.org/10.1145/2814270.2814315Google ScholarGoogle Scholar
  103. Marko van Dooren and Eric Steegmans. 2005. Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations. In Proceedings of the 20th ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications (OOPSLA’05). ACM, 455--471. DOI:DOI:https://doi.org/10.1145/1094811.1094847Google ScholarGoogle ScholarDigital LibraryDigital Library
  104. Philip Wadler and Peter Thiemann. 2003. The marriage of effects and monads. Trans. Comput. Log. 4, 1 (2003), 1--32.Google ScholarGoogle ScholarDigital LibraryDigital Library
  105. Roger Wolff, Ronald Garcia, Éric Tanter, and Jonathan Aldrich. 2011. Gradual typestate. In Proceedings of the 25th European Conference on Object-oriented Programming. 459--483. DOI:DOI:https://doi.org/10.1007/978-3-642-22655-7_22Google ScholarGoogle ScholarCross RefCross Ref
  106. Andrew K. Wright and Matthias Felleisen. 1994. A syntactic approach to type soundness. Inf. Comput. 115, 1 (1994), 38--94.Google ScholarGoogle ScholarDigital LibraryDigital Library
  107. David N. Yetter. 1990. Quantales and (noncommutative) linear logic. J. Symb. Log. 55, 01 (1990), 41--64. DOI:DOI:https://doi.org/10.2307/2274953sGoogle ScholarGoogle ScholarCross RefCross Ref

Index Terms

  1. Polymorphic Iterable Sequential Effect Systems

    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

    • Published in

      cover image ACM Transactions on Programming Languages and Systems
      ACM Transactions on Programming Languages and Systems  Volume 43, Issue 1
      March 2021
      239 pages
      ISSN:0164-0925
      EISSN:1558-4593
      DOI:10.1145/3450362
      Issue’s Table of Contents

      Copyright © 2021 ACM

      Publisher

      Association for Computing Machinery

      New York, NY, United States

      Publication History

      • Published: 17 April 2021
      • Accepted: 1 February 2021
      • Revised: 1 October 2020
      • Received: 1 May 2019
      Published in toplas Volume 43, Issue 1

      Permissions

      Request permissions about this article.

      Request Permissions

      Check for updates

      Qualifiers

      • research-article
      • Research
      • Refereed

    PDF Format

    View or Download as a PDF file.

    PDF

    eReader

    View online with eReader.

    eReader

    HTML Format

    View this article in HTML Format .

    View HTML Format
    About Cookies On This Site

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

    Learn more

    Got it!