skip to main content
research-article
Open Access

Data flow refinement type inference

Published:04 January 2021Publication History
Skip Abstract Section

Abstract

Refinement types enable lightweight verification of functional programs. Algorithms for statically inferring refinement types typically work by reduction to solving systems of constrained Horn clauses extracted from typing derivations. An example is Liquid type inference, which solves the extracted constraints using predicate abstraction. However, the reduction to constraint solving in itself already signifies an abstraction of the program semantics that affects the precision of the overall static analysis. To better understand this issue, we study the type inference problem in its entirety through the lens of abstract interpretation. We propose a new refinement type system that is parametric with the choice of the abstract domain of type refinements as well as the degree to which it tracks context-sensitive control flow information. We then derive an accompanying parametric inference algorithm as an abstract interpretation of a novel data flow semantics of functional programs. We further show that the type system is sound and complete with respect to the constructed abstract semantics. Our theoretical development reveals the key abstraction steps inherent in refinement type inference algorithms. The trade-off between precision and efficiency of these abstraction steps is controlled by the parameters of the type system. Existing refinement type systems and their respective inference algorithms, such as Liquid types, are captured by concrete parameter instantiations. We have implemented our framework in a prototype tool and evaluated it for a range of new parameter instantiations (e.g., using octagons and polyhedra for expressing type refinements). The tool compares favorably against other existing tools. Our evaluation indicates that our approach can be used to systematically construct new refinement type inference algorithms that are both robust and precise.

References

  1. Andrew W. Appel and David A. McAllester. 2001. An indexed model of recursive types for foundational proof-carrying code. ACM Trans. Program. Lang. Syst. 23, 5 ( 2001 ), 657-683. https://doi.org/10.1145/504709.504712 Google ScholarGoogle ScholarDigital LibraryDigital Library
  2. Vincenzo Arceri, Martina Olliaro, Agostino Cortesi, and Isabella Mastroeni. 2019. Completeness of Abstract Domains for String Analysis of JavaScript Programs. In Theoretical Aspects of Computing-ICTAC 2019-16th International Colloquium, Hammamet, Tunisia, October 31-November 4, 2019, Proceedings (Lecture Notes in Computer Science, Vol. 11884 ), Robert M. Hierons and Mohamed Mosbah (Eds.). Springer, 255-272. https://doi.org/10.1007/978-3-030-32505-3_15 Google ScholarGoogle ScholarCross RefCross Ref
  3. Roberto Bagnara, Patricia M. Hill, and Enea Zafanella. 2008. The Parma Polyhedra Library: Toward a complete set of numerical abstractions for the analysis and verification of hardware and software systems. Sci. Comput. Program. 72, 1-2 ( 2008 ), 3-21. https://doi.org/10.1016/j.scico. 2007. 08.001 Google ScholarGoogle ScholarDigital LibraryDigital Library
  4. Bruno Blanchet, Patrick Cousot, Radhia Cousot, Jérôme Feret, Laurent Mauborgne, Antoine Miné, David Monniaux, and Xavier Rival. 2007. A Static Analyzer for Large Safety-Critical Software. CoRR abs/cs/0701193 ( 2007 ). arXiv:cs/0701193 http://arxiv.org/abs/cs/0701193Google ScholarGoogle Scholar
  5. Adrien Champion, Tomoya Chiba, Naoki Kobayashi, and Ryosuke Sato. 2018a. ICE-Based Refinement Type Discovery for Higher-Order Functional Programs. In Tools and Algorithms for the Construction and Analysis of Systems-24th International Conference, TACAS 2018, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2018, Thessaloniki, Greece, April 14-20, 2018, Proceedings, Part I (Lecture Notes in Computer Science, Vol. 10805 ), Dirk Beyer and Marieke Huisman (Eds.). Springer, 365-384. https://doi.org/10.1007/978-3-319-89960-2_20 Google ScholarGoogle ScholarCross RefCross Ref
  6. Adrien Champion, Naoki Kobayashi, and Ryosuke Sato. 2018b. HoIce: An ICE-Based Non-linear Horn Clause Solver. In Programming Languages and Systems-16th Asian Symposium, APLAS 2018, Wellington, New Zealand, December 2-6, 2018, Proceedings (Lecture Notes in Computer Science, Vol. 11275 ), Sukyoung Ryu (Ed.). Springer, 146-156. https: //doi.org/10.1007/978-3-030-02768-1_8 Google ScholarGoogle ScholarCross RefCross Ref
  7. Liqian Chen, Antoine Miné, Ji Wang, and Patrick Cousot. 2009. Interval Polyhedra: An Abstract Domain to Infer Interval Linear Relationships. In Static Analysis, 16th International Symposium, SAS 2009, Los Angeles, CA, USA, August 9-11, 2009. Proceedings (Lecture Notes in Computer Science, Vol. 5673 ), Jens Palsberg and Zhendong Su (Eds.). Springer, 309-325. https://doi.org/10.1007/978-3-642-03237-0_21 Google ScholarGoogle ScholarDigital LibraryDigital Library
  8. Ravi Chugh, David Herman, and Ranjit Jhala. 2012. Dependent types for JavaScript. In Proceedings of the 27th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2012, part of SPLASH 2012, Tucson, AZ, USA, October 21-25, 2012, Gary T. Leavens and Matthew B. Dwyer (Eds.). ACM, 587-606. https://doi.org/10.1145/2384616.2384659 Google ScholarGoogle ScholarDigital LibraryDigital Library
  9. Patrick Cousot. 1997. Types as abstract interpretations. In Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. ACM, 316-331.Google ScholarGoogle ScholarDigital LibraryDigital Library
  10. Patrick Cousot and Radhia Cousot. 1977. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages. ACM, 238-252.Google ScholarGoogle ScholarDigital LibraryDigital Library
  11. Patrick Cousot and Radhia Cousot. 1979. Systematic design of program analysis frameworks. In Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages. ACM, 269-282.Google ScholarGoogle ScholarDigital LibraryDigital Library
  12. Patrick Cousot and Radhia Cousot. 1994. Invited Talk: Higher Order Abstract Interpretation (and Application to Comportment Analysis Generalizing Strictness, Termination, Projection, and PER Analysis. In Proceedings of the IEEE Computer Society 1994 International Conference on Computer Languages, May 16-19, 1994, Toulouse, France, Henri E. Bal (Ed.). IEEE Computer Society, 95-112. https://doi.org/10.1109/ICCL. 1994.288389 Google ScholarGoogle ScholarCross RefCross Ref
  13. Patrick Cousot, Radhia Cousot, Jérôme Feret, Laurent Mauborgne, Antoine Miné, and Xavier Rival. 2009. Why does Astrée scale up? Formal Methods Syst. Des. 35, 3 ( 2009 ), 229-264. https://doi.org/10.1007/s10703-009-0089-6 Google ScholarGoogle ScholarDigital LibraryDigital Library
  14. Patrick Cousot and Nicolas Halbwachs. 1978. Automatic Discovery of Linear Restraints Among Variables of a Program. In Conference Record of the Fifth Annual ACM Symposium on Principles of Programming Languages, Tucson, Arizona, USA, January 1978, Alfred V. Aho, Stephen N. Zilles, and Thomas G. Szymanski (Eds.). ACM Press, 84-96. https: //doi.org/10.1145/512760.512770 Google ScholarGoogle ScholarDigital LibraryDigital Library
  15. Joshua Dunfield and Frank Pfenning. 2003. Type Assignment for Intersections and Unions in Call-by-Value Languages. In Foundations of Software Science and Computational Structures, 6th International Conference, FOSSACS 2003 Held as Part of the Joint European Conference on Theory and Practice of Software, ETAPS 2003, Warsaw, Poland, April 7-11, 2003, Proceedings (Lecture Notes in Computer Science, Vol. 2620 ), Andrew D. Gordon (Ed.). Springer, 250-266. https://doi.org/10.1007/3-540-36576-1_16 Google ScholarGoogle ScholarCross RefCross Ref
  16. Joshua Dunfield and Frank Pfenning. 2004. Tridirectional typechecking. In Proceedings of the 31st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2004, Venice, Italy, January 14-16, 2004, Neil D. Jones and Xavier Leroy (Eds.). ACM, 281-292. https://doi.org/10.1145/964001.964025 Google ScholarGoogle ScholarDigital LibraryDigital Library
  17. Cormac Flanagan and K. Rustan M. Leino. 2001. Houdini, an Annotation Assistant for ESC/Java. In FME 2001: Formal Methods for Increasing Software Productivity, International Symposium of Formal Methods Europe, Berlin, Germany, March 12-16, 2001, Proceedings (Lecture Notes in Computer Science, Vol. 2021 ), José Nuno Oliveira and Pamela Zave (Eds.). Springer, 500-517. https://doi.org/10.1007/3-540-45251-6_29 Google ScholarGoogle ScholarCross RefCross Ref
  18. Timothy S. Freeman and Frank Pfenning. 1991. Refinement Types for ML. In Proceedings of the ACM SIGPLAN'91 Conference on Programming Language Design and Implementation (PLDI), Toronto, Ontario, Canada, June 26-28, 1991, David S. Wise (Ed.). ACM, 268-277. https://doi.org/10.1145/113445.113468 Google ScholarGoogle ScholarDigital LibraryDigital Library
  19. Ronald Garcia, Alison M. Clark, and Éric Tanter. 2016. Abstracting gradual typing. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2016, St. Petersburg, FL, USA, January 20-22, 2016, Rastislav Bodík and Rupak Majumdar (Eds.). ACM, 429-442. https://doi.org/10.1145/2837614.2837670 Google ScholarGoogle ScholarDigital LibraryDigital Library
  20. Pranav Garg, Christof Löding, P. Madhusudan, and Daniel Neider. 2014. ICE: A Robust Framework for Learning Invariants. In Computer Aided Verification-26th International Conference, CAV 2014, Held as Part of the Vienna Summer of Logic, VSL 2014, Vienna, Austria, July 18-22, 2014. Proceedings (Lecture Notes in Computer Science, Vol. 8559 ), Armin Biere and Roderick Bloem (Eds.). Springer, 69-87. https://doi.org/10.1007/978-3-319-08867-9_5 Google ScholarGoogle ScholarDigital LibraryDigital Library
  21. Thomas Gilray, Steven Lyde, Michael D. Adams, Matthew Might, and David Van Horn. 2016. Pushdown control-flow analysis for free. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2016, St. Petersburg, FL, USA, January 20-22, 2016, Rastislav Bodík and Rupak Majumdar (Eds.). ACM, 691-704. https://doi.org/10.1145/2837614.2837631 Google ScholarGoogle ScholarDigital LibraryDigital Library
  22. Roberta Gori and Giorgio Levi. 2002. An Experiment in Type Inference and Verification by Abstract Interpretation. In Verification, Model Checking, and Abstract Interpretation, Third International Workshop, VMCAI 2002, Venice, Italy, January 21-22, 2002, Revised Papers (Lecture Notes in Computer Science, Vol. 2294 ), Agostino Cortesi (Ed.). Springer, 225-239. https://doi.org/10.1007/3-540-47813-2_16 Google ScholarGoogle ScholarCross RefCross Ref
  23. Roberta Gori and Giorgio Levi. 2003. Properties of a Type Abstract Interpreter. In Verification, Model Checking, and Abstract Interpretation, 4th International Conference, VMCAI 2003, New York, NY, USA, January 9-11, 2002, Proceedings (Lecture Notes in Computer Science, Vol. 2575 ), Lenore D. Zuck, Paul C. Attie, Agostino Cortesi, and Supratik Mukhopadhyay (Eds.). Springer, 132-145. https://doi.org/10.1007/3-540-36384-X_13 Google ScholarGoogle ScholarCross RefCross Ref
  24. Robert Harper. 1992. Constructing Type Systems over an Operational Semantics. J. Symb. Comput. 14, 1 ( 1992 ), 71-84. https://doi.org/10.1016/ 0747-7171 ( 92 ) 90026-Z Google ScholarGoogle ScholarDigital LibraryDigital Library
  25. David Van Horn and Matthew Might. 2011. Abstracting abstract machines: a systematic approach to higher-order program analysis. Commun. ACM 54, 9 ( 2011 ), 101-109. https://doi.org/10.1145/1995376.1995400 Google ScholarGoogle ScholarDigital LibraryDigital Library
  26. Suresh Jagannathan and Stephen Weeks. 1995. A Unified Treatment of Flow Analysis in Higher-order Languages. In Proceedings of the 22Nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (San Francisco, California, USA). ACM, 393-407. https://doi.org/10.1145/199448.199536 Google ScholarGoogle ScholarDigital LibraryDigital Library
  27. Bertrand Jeannet and Antoine Miné. 2009. Apron: A Library of Numerical Abstract Domains for Static Analysis. In Computer Aided Verification, 21st International Conference, CAV 2009, Grenoble, France, June 26-July 2, 2009. Proceedings (Lecture Notes in Computer Science, Vol. 5643 ), Ahmed Bouajjani and Oded Maler (Eds.). Springer, 661-667. https: //doi.org/10.1007/978-3-642-02658-4_52 Google ScholarGoogle ScholarDigital LibraryDigital Library
  28. Neil D. Jones and Nils Andersen. 2007. Flow Analysis of Lazy Higher-order Functional Programs. Theor. Comput. Sci. 375, 1-3 ( April 2007 ), 120-136. https://doi.org/10.1016/j.tcs. 2006. 12.030 Google ScholarGoogle ScholarDigital LibraryDigital Library
  29. Neil D. Jones and Alan Mycroft. 1986. Data Flow Analysis of Applicative Programs Using Minimal Function Graphs. In Conference Record of the Thirteenth Annual ACM Symposium on Principles of Programming Languages, St. Petersburg Beach, Florida, USA, January 1986. ACM Press, 296-306. https://doi.org/10.1145/512644.512672 Google ScholarGoogle ScholarDigital LibraryDigital Library
  30. Neil D. Jones and Mads Rosendahl. 1997. Higher-Order Minimal Function Graphs. J. Funct. Log. Program. 1997, 2 ( 1997 ). http://danae.uni-muenster.de/lehre/kuchen/JFLP/articles/1997/A97-02/ A97-02.htmlGoogle ScholarGoogle Scholar
  31. Milod Kazerounian, Niki Vazou, Austin Bourgerie, Jefrey S. Foster, and Emina Torlak. 2018. Refinement Types for Ruby. In Verification, Model Checking, and Abstract Interpretation-19th International Conference, VMCAI 2018, Los Angeles, CA, USA, January 7-9, 2018, Proceedings (Lecture Notes in Computer Science, Vol. 10747 ), Isil Dillig and Jens Palsberg (Eds.). Springer, 269-290. https://doi.org/10.1007/978-3-319-73721-8_13 Google ScholarGoogle ScholarCross RefCross Ref
  32. Se-Won Kim and Kwang-Moo Choe. 2011. String Analysis as an Abstract Interpretation. In Verification, Model Checking, and Abstract Interpretation-12th International Conference, VMCAI 2011, Austin, TX, USA, January 23-25, 2011. Proceedings (Lecture Notes in Computer Science, Vol. 6538 ), Ranjit Jhala and David A. Schmidt (Eds.). Springer, 294-308. https: //doi.org/10.1007/978-3-642-18275-4_21 Google ScholarGoogle ScholarCross RefCross Ref
  33. Naoki Kobayashi, Ryosuke Sato, and Hiroshi Unno. 2011. Predicate abstraction and CEGAR for higher-order model checking. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2011, San Jose, CA, USA, June 4-8, 2011, Mary W. Hall and David A. Padua (Eds.). ACM, 222-233. https://doi.org/10.1145/ 1993498.1993525 Google ScholarGoogle ScholarDigital LibraryDigital Library
  34. Shuvendu K. Lahiri and Shaz Qadeer. 2009. Complexity and Algorithms for Monomial and Clausal Predicate Abstraction. In Automated Deduction-CADE-22, 22nd International Conference on Automated Deduction, Montreal, Canada, August 2-7, 2009. Proceedings (Lecture Notes in Computer Science, Vol. 5663 ), Renate A. Schmidt (Ed.). Springer, 214-229. https: //doi.org/10.1007/978-3-642-02959-2_18 Google ScholarGoogle ScholarDigital LibraryDigital Library
  35. Nico Lehmann and Éric Tanter. 2017. Gradual refinement types. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18-20, 2017, Giuseppe Castagna and Andrew D. Gordon (Eds.). ACM, 775-788. http://dl.acm.org/citation.cfm?id= 3009856Google ScholarGoogle Scholar
  36. Laurent Mauborgne and Xavier Rival. 2005. Trace Partitioning in Abstract Interpretation Based Static Analyzers. In Programming Languages and Systems, 14th European Symposium on Programming,ESOP 2005, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2005, Edinburgh, UK, April 4-8, 2005, Proceedings (Lecture Notes in Computer Science, Vol. 3444 ), Shmuel Sagiv (Ed.). Springer, 5-20. https://doi.org/10.1007/978-3-540-31987-0_2 Google ScholarGoogle ScholarDigital LibraryDigital Library
  37. Jan Midtgaard. 2012. Control-flow analysis of functional programs. ACM Comput. Surv. 44, 3 ( 2012 ), 10 : 1-10 : 33. https: //doi.org/10.1145/2187671.2187672 Google ScholarGoogle ScholarDigital LibraryDigital Library
  38. Antoine Miné. 2007. The Octagon Abstract Domain. CoRR abs/cs/0703084 ( 2007 ). arXiv:cs/0703084 http://arxiv.org/abs/cs/ 0703084Google ScholarGoogle Scholar
  39. Bruno Monsuez. 1992. Polymorphic typing by abstract interpretation. In International Conference on Foundations of Software Technology and Theoretical Computer Science. Springer, 217-228.Google ScholarGoogle ScholarCross RefCross Ref
  40. Bruno Monsuez. 1993. Polymorphic types and widening operators. In Static Analysis. Springer, 267-281.Google ScholarGoogle Scholar
  41. Bruno Monsuez. 1995a. System F and abstract interpretation. In International Static Analysis Symposium. Springer, 279-295.Google ScholarGoogle ScholarCross RefCross Ref
  42. Bruno Monsuez. 1995b. Using abstract interpretation to define a strictness type inference system. In Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. ACM, 122-133.Google ScholarGoogle ScholarDigital LibraryDigital Library
  43. Christian Mossin. 1998. Higher-Order Value Flow Graphs. Nord. J. Comput. 5, 3 ( 1998 ), 214-234.Google ScholarGoogle Scholar
  44. Hanne Riis Nielson and Flemming Nielson. 1997. Infinitary Control Flow Analysis: a Collecting Semantics for Closure Analysis. In Conference Record of POPL'97: The 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Papers Presented at the Symposium, Paris, France, 15-17 January 1997, Peter Lee, Fritz Henglein, and Neil D. Jones (Eds.). ACM Press, 332-345. https://doi.org/10.1145/263699.263745 Google ScholarGoogle ScholarDigital LibraryDigital Library
  45. Yuya Okuyama, Takeshi Tsukada, and Naoki Kobayashi. 2019. A Temporal Logic for Higher-Order Functional Programs. In Static Analysis-26th International Symposium, SAS 2019, Porto, Portugal, October 8-11, 2019, Proceedings (Lecture Notes in Computer Science, Vol. 11822 ), Bor-Yuh Evan Chang (Ed.). Springer, 437-458. https://doi.org/10.1007/978-3-030-32304-2_21 Google ScholarGoogle ScholarCross RefCross Ref
  46. Luke Ong. 2015. Higher-Order Model Checking: An Overview. In 30th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2015, Kyoto, Japan, July 6-10, 2015. IEEE Computer Society, 1-15. https://doi.org/10.1109/LICS. 2015.9 Google ScholarGoogle ScholarDigital LibraryDigital Library
  47. Zvonimir Pavlinovic, Yusen Su, and Thomas Wies. 2020. Data Flow Refinement Type Inference. CoRR abs/ 2011.04876 ( 2020 ). arXiv: 2011.04876 http://arxiv.org/abs/ 2011.04876Google ScholarGoogle Scholar
  48. John Plevyak and Andrew A. Chien. 1995. Iterative Flow Analysis.Google ScholarGoogle Scholar
  49. Thomas W. Reps. 1998. Program analysis via graph reachability. Inf. Softw. Technol. 40, 11-12 ( 1998 ), 701-726. https: //doi.org/10.1016/S0950-5849 ( 98 ) 00093-7 Google ScholarGoogle Scholar
  50. Patrick Maxim Rondon, Ming Kawaguchi, and Ranjit Jhala. 2008. Liquid types. In Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation, Tucson, AZ, USA, June 7-13, 2008, Rajiv Gupta and Saman P. Amarasinghe (Eds.). ACM, 159-169. https://doi.org/10.1145/1375581.1375602 Google ScholarGoogle ScholarDigital LibraryDigital Library
  51. Gagandeep Singh, Markus Püschel, and Martin T. Vechev. 2017. Fast polyhedra abstract domain. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18-20, 2017, Giuseppe Castagna and Andrew D. Gordon (Eds.). ACM, 46-59. http://dl.acm.org/citation.cfm?id= 3009885Google ScholarGoogle Scholar
  52. John Toman, Ren Siqi, Kohei Suenaga, Atsushi Igarashi, and Naoki Kobayashi. 2020. ConSORT: Context-and FlowSensitive Ownership Refinement Types for Imperative Programs. In Programming Languages and Systems-29th European Symposium on Programming, ESOP 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020, Dublin, Ireland, April 25-30, 2020, Proceedings (Lecture Notes in Computer Science, Vol. 12075 ), Peter Müller (Ed.). Springer, 684-714. https://doi.org/10.1007/978-3-030-44914-8_25 Google ScholarGoogle ScholarCross RefCross Ref
  53. Hiroshi Unno and Naoki Kobayashi. 2009. Dependent type inference with interpolants. In Proceedings of the 11th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, September 7-9, 2009, Coimbra, Portugal, António Porto and Francisco Javier López-Fraguas (Eds.). ACM, 277-288. https://doi.org/10.1145/1599410.1599445 Google ScholarGoogle ScholarDigital LibraryDigital Library
  54. Hiroshi Unno, Tachio Terauchi, and Naoki Kobayashi. 2013. Automating relatively complete verification of higher-order functional programs. In The 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '13, Rome, Italy-January 23-25, 2013, Roberto Giacobazzi and Radhia Cousot (Eds.). ACM, 75-86. https: //doi.org/10.1145/2429069.2429081 Google ScholarGoogle ScholarDigital LibraryDigital Library
  55. Dimitrios Vardoulakis and Olin Shivers. 2011a. 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
  56. Dimitrios Vardoulakis and Olin Shivers. 2011b. Pushdown flow analysis of first-class control. In Proceeding of the 16th ACM SIGPLAN international conference on Functional Programming, ICFP 2011, Tokyo, Japan, September 19-21, 2011, Manuel M. T. Chakravarty, Zhenjiang Hu, and Olivier Danvy (Eds.). ACM, 69-80. https://doi.org/10.1145/2034773.2034785 Google ScholarGoogle ScholarDigital LibraryDigital Library
  57. Niki Vazou, Alexander Bakst, and Ranjit Jhala. 2015. Bounded refinement types. In Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming, ICFP 2015, Vancouver, BC, Canada, September 1-3, 2015, Kathleen Fisher and John H. Reppy (Eds.). ACM, 48-61. https://doi.org/10.1145/2784731.2784745 Google ScholarGoogle ScholarDigital LibraryDigital Library
  58. Niki Vazou, Joachim Breitner, Rose Kunkel, David Van Horn, and Graham Hutton. 2018a. Theorem proving for all: equational reasoning in liquid Haskell (functional pearl). In Proceedings of the 11th ACM SIGPLAN International Symposium on Haskell, [email protected] 2018, St. Louis, MO, USA, September 27-17, 2018, Nicolas Wu (Ed.). ACM, 132-144. https: //doi.org/10.1145/3242744.3242756 Google ScholarGoogle ScholarDigital LibraryDigital Library
  59. Niki Vazou, Patrick Maxim Rondon, and Ranjit Jhala. 2013. Abstract Refinement Types. In Programming Languages and Systems-22nd European Symposium on Programming, ESOP 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings (Lecture Notes in Computer Science, Vol. 7792 ), Matthias Felleisen and Philippa Gardner (Eds.). Springer, 209-228. https://doi.org/10.1007/978-3-642-37036-6_13 Google ScholarGoogle ScholarDigital LibraryDigital Library
  60. Niki Vazou, Eric L. Seidel, Ranjit Jhala, Dimitrios Vytiniotis, and Simon L. Peyton Jones. 2014. Refinement types for Haskell. In Proceedings of the 19th ACM SIGPLAN international conference on Functional programming, Gothenburg, Sweden, September 1-3, 2014, Johan Jeuring and Manuel M. T. Chakravarty (Eds.). ACM, 269-282. https://doi.org/10.1145/2628136.2628161 Google ScholarGoogle ScholarDigital LibraryDigital Library
  61. Niki Vazou, Éric Tanter, and David Van Horn. 2018b. Gradual liquid type inference. Proc. ACM Program. Lang. 2, OOPSLA ( 2018 ), 132 : 1-132 : 25. https://doi.org/10.1145/3276502 Google ScholarGoogle ScholarDigital LibraryDigital Library
  62. Panagiotis Vekris, Benjamin Cosman, and Ranjit Jhala. 2016. Refinement types for TypeScript. In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2016, Santa Barbara, CA, USA, June 13-17, 2016, Chandra Krintz and Emery Berger (Eds.). ACM, 310-325. https://doi.org/10.1145/2908080.2908110 Google ScholarGoogle ScholarDigital LibraryDigital Library
  63. Philip Wadler. 1990. Comprehending Monads. In Proceedings of the 1990 ACM Conference on LISP and Functional Programming, LFP 1990, Nice, France, 27-29 June 1990. ACM, 61-78. https://doi.org/10.1145/91556.91592 Google ScholarGoogle ScholarDigital LibraryDigital Library
  64. Hongwei Xi and Frank Pfenning. 1999. Dependent Types in Practical Programming. In POPL '99, Proceedings of the 26th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Antonio, TX, USA, January 20-22, 1999, Andrew W. Appel and Alex Aiken (Eds.). ACM, 214-227. https://doi.org/10.1145/292540.292560 Google ScholarGoogle ScholarDigital LibraryDigital Library
  65. He Zhu and Suresh Jagannathan. 2013. Compositional and Lightweight Dependent Type Inference for ML. In Verification, Model Checking, and Abstract Interpretation, 14th International Conference, VMCAI 2013, Rome, Italy, January 20-22, 2013. Proceedings (Lecture Notes in Computer Science, Vol. 7737 ), Roberto Giacobazzi, Josh Berdine, and Isabella Mastroeni (Eds.). Springer, 295-314. https://doi.org/10.1007/978-3-642-35873-9_19 Google ScholarGoogle ScholarDigital LibraryDigital Library
  66. He Zhu, Aditya V. Nori, and Suresh Jagannathan. 2015. Learning refinement types. In Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming, ICFP 2015, Vancouver, BC, Canada, September 1-3, 2015, Kathleen Fisher and John H. Reppy (Eds.). ACM, 400-411. https://doi.org/10.1145/2784731.2784766 Google ScholarGoogle ScholarDigital LibraryDigital Library
  67. He Zhu, Gustavo Petri, and Suresh Jagannathan. 2016. Automatically learning shape specifications. In Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2016, Santa Barbara, CA, USA, June 13-17, 2016, Chandra Krintz and Emery Berger (Eds.). ACM, 491-507. https://doi.org/10.1145/2908080.2908125 Google ScholarGoogle ScholarDigital LibraryDigital Library

Index Terms

  1. Data flow refinement type inference

      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!