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.
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- Antoine Miné. 2007. The Octagon Abstract Domain. CoRR abs/cs/0703084 ( 2007 ). arXiv:cs/0703084 http://arxiv.org/abs/cs/ 0703084Google Scholar
- Bruno Monsuez. 1992. Polymorphic typing by abstract interpretation. In International Conference on Foundations of Software Technology and Theoretical Computer Science. Springer, 217-228.Google Scholar
Cross Ref
- Bruno Monsuez. 1993. Polymorphic types and widening operators. In Static Analysis. Springer, 267-281.Google Scholar
- Bruno Monsuez. 1995a. System F and abstract interpretation. In International Static Analysis Symposium. Springer, 279-295.Google Scholar
Cross Ref
- 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 Scholar
Digital Library
- Christian Mossin. 1998. Higher-Order Value Flow Graphs. Nord. J. Comput. 5, 3 ( 1998 ), 214-234.Google Scholar
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
- John Plevyak and Andrew A. Chien. 1995. Iterative Flow Analysis.Google Scholar
- 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 Scholar
- 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 Scholar
Digital Library
- 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 Scholar
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Cross Ref
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
- 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 Scholar
Digital Library
Index Terms
Data flow refinement type inference
Recommendations
Refinement types for Haskell
PLPV '14: Proceedings of the ACM SIGPLAN 2014 Workshop on Programming Languages meets Program VerificationWe present LiquidHaskell (http://goto.ucsd.edu/liquid), an automatic verifier for Haskell. LiquidHaskell uses Refinement types, a restricted form of dependent types where relationships between values are encoded by decorating types with logical ...
Gradual liquid type inference
Refinement types allow for lightweight program verification by enriching types with logical predicates. Liquid typing provides a decidable refinement inference mechanism that is convenient but subject to two major issues: (1) inference is global and ...
Deriving a complete type inference for Hindley-Milner and vector sizes using expansion
Type inference and program analysis both infer static properties about a program. Yet, they are constructed using very different techniques. We reconcile both approaches by deriving a type inference from a denotational semantics using abstract ...






Comments