Bibliography

@book{haskell98, added-at = {2008-01-15T20:00:13.000+0100}, description = {This report defines the syntax for Haskell programs and an informal abstract semantics for the meaning of such programs.}, editor = {Jones, Simon Peyton}, howpublished = {PDF}, keywords = {functional-programming haskell}, month = {September}, pages = 277, publisher = {http://haskell.org/}, timestamp = {2008-01-15T20:00:13.000+0100}, title = {Haskell 98 Language and Libraries: The Revised Report}, type = {Language Definition}, url = {http://haskell.org/definition/haskell98-report.pdf}, year = 2002} @article{beaven1993explaining, author = {Beaven, Mike and Stansifer, Ryan}, title = {Explaining Type Errors in Polymorphic Languages}, year = {1993}, issue_date = {March–Dec. 1993}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {2}, number = {1–4}, issn = {1057-4514}, url = {https://doi.org/10.1145/176454.176460}, doi = {10.1145/176454.176460}, journal = {ACM Lett. Program. Lang. Syst.}, month = {mar}, pages = {17–30}, numpages = {14}, keywords = {type errors, polymorphic type reconstruction}} @article{bernstein1995debugging, title={Debugging type errors (full version)}, author={Bernstein, Karen L and Stark, Eugene W}, journal={Unpublished Technical Report, Computer Science Dept. State University of New York at Stony Brook}, year={1995}, publisher={Citeseer}} @inproceedings{chen2014conterfactual, author = {Chen, Sheng and Erwig, Martin}, title = {Counter-Factual Typing for Debugging Type Errors}, year = {2014}, isbn = {9781450325448}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/2535838.2535863}, doi = {10.1145/2535838.2535863}, booktitle = {Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages}, pages = {583–594}, numpages = {12}, keywords = {error localization, type-error debugging, change suggestions, type error messages, choice types, type inference}, location = {San Diego, California, USA}, series = {POPL '14}} @inproceedings{chen2014guide, author="Chen, Sheng and Erwig, Martin", editor="Codish, Michael and Sumii, Eijiro", title="Guided Type Debugging", booktitle="Functional and Logic Programming", year="2014", publisher="Springer International Publishing", address="Cham", pages="35--51", isbn="978-3-319-07151-0"} @inproceedings{chitil2001composition, author = {Chitil, Olaf}, title = {Compositional Explanation of Types and Algorithmic Debugging of Type Errors}, year = {2001}, isbn = {1581134150}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/507635.507659}, doi = {10.1145/507635.507659}, booktitle = {Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming}, pages = {193–204}, numpages = {12}, location = {Florence, Italy}, series = {ICFP '01}} @misc{dieselwiki, author = {Diesel Contributors}, title = {{diesel-rs} GitHub Discussions}, howpublished = {\url{https://github.com/diesel-rs/diesel/discussions?discussions_q=not+implemented+for}}, note = {Accessed: 2024-04-24}} @inproceedings{damas1982inference, author = {Damas, Luis and Milner, Robin}, title = {Principal Type-Schemes for Functional Programs}, year = {1982}, isbn = {0897910656}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/582153.582176}, doi = {10.1145/582153.582176}, booktitle = {Proceedings of the 9th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages}, pages = {207–212}, numpages = {6}, location = {Albuquerque, New Mexico}, series = {POPL '82}} @article{dewar1986prolog, title = {Graphical display of complex information within a Prolog debugger}, journal = {International Journal of Man-Machine Studies}, volume = {25}, number = {5}, pages = {503-521}, year = {1986}, issn = {0020-7373}, doi = {https://doi.org/10.1016/S0020-7373(86)80020-7}, url = {https://www.sciencedirect.com/science/article/pii/S0020737386800207}, author = {Alan D. Dewar and John G. Cleary},} @techreport{ducasse1998opium, title = {{Abstract Views of Prolog Executions in Opium}}, author = {Ducass{\'e}, Mireille}, url = {https://inria.hal.science/inria-00073154}, type = {Research Report}, number = {RR-3531}, institution = {{INRIA}}, year = {1998}, keywords = {SOFTWARE ENGINEERING ; PROGRAMMING ENVIRONMENT ; AUTOMATED DEBUGGING ; TRACE QUERY MECHANISM ; DEBUGGING LANGUAGE ; PROGRAM BEHAVIOR UNDERSTANDING ; DEBUGGING TOOL ; PROLOG}, pdf = {https://inria.hal.science/inria-00073154/file/RR-3531.pdf}, hal_id = {inria-00073154}, hal_version = {v1},} @article{duggan1996explaining, title = {Explaining type inference}, journal = {Science of Computer Programming}, volume = {27}, number = {1}, pages = {37-83}, year = {1996}, issn = {0167-6423}, doi = {https://doi.org/10.1016/0167-6423(95)00007-0}, url = {https://www.sciencedirect.com/science/article/pii/0167642395000070}, author = {Dominic Duggan and Frederick Bent},} @article{eisenstadt1988transparent, title={The Transparent Prolog Machine (TPM): an execution model and graphical debugger for logic programming}, author={Eisenstadt, Marc and Brayshaw, Mike}, journal={The Journal of Logic Programming}, volume={5}, number={4}, pages={277--342}, year={1988}, publisher={Elsevier}} @misc{frank2021coq, title={The Coq Proof Script Visualiser (coq-psv)}, author={Mario Frank}, year={2021}, eprint={2101.07761}, archivePrefix={arXiv}, primaryClass={cs.LO}} @inproceedings{hage2007heuristic, author="Hage, Jurriaan and Heeren, Bastiaan", editor="Horv{\'a}th, Zolt{\'a}n and Zs{\'o}k, Vikt{\'o}ria and Butterfield, Andrew", title="Heuristics for Type Error Discovery and Recovery", booktitle="Implementation and Application of Functional Languages", year="2007", publisher="Springer Berlin Heidelberg", address="Berlin, Heidelberg", pages="199--216", isbn="978-3-540-74130-5"} @inproceedings{hage2006heuristics, author = {Hage, Jurriaan and Heeren, Bastiaan}, title = {Heuristics for Type Error Discovery and Recovery}, year = {2006}, isbn = {9783540741299}, publisher = {Springer-Verlag}, address = {Berlin, Heidelberg}, booktitle = {Proceedings of the 18th International Conference on Implementation and Application of Functional Languages}, pages = {199–216}, numpages = {18}, keywords = {constraints, error messages, type graph, error recovery, type inferencing, heuristics}, location = {Budapest, Hungary}, series = {IFL'06}} @inproceedings{heeren2003scripting, author = {Heeren, Bastiaan and Hage, Jurriaan and Swierstra, S. Doaitse}, title = {Scripting the Type Inference Process}, year = {2003}, isbn = {1581137567}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/944705.944707}, doi = {10.1145/944705.944707}, abstract = {To improve the quality of type error messages in functional programming languages,we propose four techniques which influence the behaviour of constraint-based type inference processes. These techniques take the form of externally supplied type inference directives, precluding the need to make any changes to the compiler. A second advantage is that the directives are automatically checked for soundness with respect to the underlying type system. We show how the techniques can be used to improve the type error messages reported for a combinator library. More specifically, how they can help to generate error messages which are conceptually closer to the domain for which the library was developed. The techniques have all been incorporated in the Helium compiler, which implements a large subset of Haskell.}, booktitle = {Proceedings of the Eighth ACM SIGPLAN International Conference on Functional Programming}, pages = {3–13}, numpages = {11}, keywords = {type inference, type errors, domain-specific programming, directives, constraints}, location = {Uppsala, Sweden}, series = {ICFP '03}} @inproceedings{heeren2003helium, author = {Heeren, Bastiaan and Leijen, Daan and van IJzendoorn, Arjan}, title = {Helium, for Learning Haskell}, year = {2003}, isbn = {1581137583}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/871895.871902}, doi = {10.1145/871895.871902}, booktitle = {Proceedings of the 2003 ACM SIGPLAN Workshop on Haskell}, pages = {62–71}, numpages = {10}, keywords = {learning Haskell, education, type inference, error logging, error messages}, location = {Uppsala, Sweden}, series = {Haskell '03}} @techreport{kangfeatureorienteddomain1990, title={Feature-Oriented Domain Analysis (FODA) Feasibility Study}, author={Kyo Kang and Sholom Cohen and James Hess and William Novak and A. Peterson}, year={1990}, number={CMU/SEI-90-TR-021 }, institution={Software Engineering Institute, Carnegie Mellon University}, address={Pittsburgh, PA}, url={http://resources.sei.cmu.edu/library/asset-view.cfm?AssetID=11231}} @misc{paperproof, author = {Karunus, Evgenia and Kovsharov, Anton }, title = {Paperproof}, year = {2023}, publisher = {GitHub}, journal = {GitHub repository}, howpublished = {\url{https://github.com/Paper-Proof/paperproof}},} @misc{trafhide, author = {Kawabata, Hideyuki }, title = {Traf}, year = {2018}, publisher = {GitHub}, journal = {GitHub repository}, howpublished = {\url{https://github.com/hide-kawabata/traf}},} @inproceedings{lerner2007search, author = {Lerner, Benjamin S. and Flower, Matthew and Grossman, Dan and Chambers, Craig}, title = {Searching for Type-Error Messages}, year = {2007}, isbn = {9781595936332}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/1250734.1250783}, doi = {10.1145/1250734.1250783}, booktitle = {Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation}, pages = {425–434}, numpages = {10}, keywords = {type-inference, error messages, objective Caml, seminal, type-checking}, location = {San Diego, California, USA}, series = {PLDI '07}} @inproceedings{loncaric2016type, author = {Loncaric, Calvin and Chandra, Satish and Schlesinger, Cole and Sridharan, Manu}, title = {A Practical Framework for Type Inference Error Explanation}, year = {2016}, isbn = {9781450344449}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/2983990.2983994}, doi = {10.1145/2983990.2983994}, booktitle = {Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications}, pages = {781–799}, numpages = {19}, keywords = {Type Inference, Type Error Diagnosis}, location = {Amsterdam, Netherlands}, series = {OOPSLA 2016}} @inproceedings{matsakis2014rust, title={The rust language}, author={Matsakis, Nicholas D and Klock II, Felix S}, booktitle={ACM SIGAda Ada Letters}, volume={34}, number={3}, pages={103--104}, year={2014}, organization={ACM}} @misc{odersky2004scala, title={The Scala language specification}, author={Odersky, Martin and Altherr, Philippe and Cremet, Vincent and Emir, Burak and Micheloud, Stphane and Mihaylov, Nikolay and Schinz, Michel and Stenman, Erik and Zenger, Matthias}, year={2004}, publisher={Citeseer}} @inproceedings{pavlinovic2014type, author = {Pavlinovic, Zvonimir and King, Tim and Wies, Thomas}, title = {Finding Minimum Type Error Sources}, year = {2014}, isbn = {9781450325851}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/2660193.2660230}, doi = {10.1145/2660193.2660230}, booktitle = {Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages \& Applications}, pages = {525–542}, numpages = {18}, keywords = {type errors, satisfiability modulo theories, diagnostics}, location = {Portland, Oregon, USA}, series = {OOPSLA '14}} @inproceedings{peytonjones1997type, author = {Peyton Jones, Simon and Jones, Mark and Meijer, Erik}, title = {Type classes: an exploration of the design space}, booktitle = {Haskell workshop}, year = {1997}, month = {January}, abstract = {When type classes were first introduced in Haskell they were regarded as a fairly experimental language feature, and therefore warranted a fairly conservative design. Since that time, practical experience has convinced many programmers of the benefits and convenience of type classes. However, on occasion, these same programmers have discovered examples where seemingly natural applications for type class overloading are prevented by the restrictions imposed by the Haskell design. It is possible to extend the type class mechanism of Haskell in various ways to overcome these limitations, but such proposals must be designed with great care. For example, several different extensions have been implemented in Gofer. Some of these, particularly the support for multi-parameter classes, have proved to be very useful, but interactions between other aspects of the design have resulted in a type system that is both unsound and undecidable. Another illustration is the introduction of constructor classes in Haskell 1.3, which came without the proper generalization of the notion of a context. As a consequence, certain quite reasonable programs are not typable. In this paper we review the rationale behind the design of Haskell's class system, we identify some of the weaknesses in the current situation, and we explain the choices that we face in attempting to remove them.}, url = {https://www.microsoft.com/en-us/research/publication/type-classes-an-exploration-of-the-design-space/}, edition = {Haskell workshop},} @inproceedings{pitclaudelalectryon, author = {Pit-Claudel, Cl\'{e}ment}, title = {Untangling mechanized proofs}, year = {2020}, isbn = {9781450381765}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3426425.3426940}, doi = {10.1145/3426425.3426940}, abstract = {Proof assistants like Coq, Lean, or HOL4 rely heavily on stateful meta-programs called scripts to assemble proofs. Unlike pen-and-paper proofs, proof scripts only describe the steps to take (induct on x, apply a theorem, …), not the states that these steps lead to; as a result, plain proof scripts are essentially incomprehensible without the assistance of an interactive user interface able to run the script and show the corresponding proof states. Until now, the standard process to communicate a proof without forcing readers to execute its script was to manually copy-paste intermediate proof states into the script, as source code comments — a tedious and error-prone exercise. Additional prose (such as for a book or tutorial) was likewise embedded in comments, preserving executability at the cost of a mediocre text-editing experience. This paper describes a new approach to the development and dissemination of literate proof scripts, with a focus on the Coq proof assistant. Specifically, we describe two contributions: a compiler that interleaves Coq’s output with the original proof script to produce interactive webpages that are complete, self-contained presentations of Coq proofs; and a new literate programming toolkit that allows authors to switch seamlessly between prose- and code-oriented views of the same sources, by translating back and forth between reStructuredText documents and literate Coq source files. In combination, these tools offer a new way to write, communicate, and preserve proofs, combining the flexibility of procedural proof scripts and the intelligibility of declarative proofs.}, booktitle = {Proceedings of the 13th ACM SIGPLAN International Conference on Software Language Engineering}, pages = {155–174}, numpages = {20}, keywords = {formal verification, literate programming, proof browsing, proof presentation}, location = {Virtual, USA}, series = {SLE 2020}} @inproceedings{ringer2020replica, author = {Ringer, Talia and Sanchez-Stern, Alex and Grossman, Dan and Lerner, Sorin}, title = {REPLica: REPL Instrumentation for Coq Analysis}, year = {2020}, isbn = {9781450370974}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3372885.3373823}, doi = {10.1145/3372885.3373823}, booktitle = {Proceedings of the 9th ACM SIGPLAN International Conference on Certified Programs and Proofs}, pages = {99–113}, numpages = {15}, keywords = {user interaction, study methodologies, proof engineering}, location = {New Orleans, LA, USA}, series = {CPP 2020}} @inproceedings{sakkas2020repair, author = {Sakkas, Georgios and Endres, Madeline and Cosman, Benjamin and Weimer, Westley and Jhala, Ranjit}, title = {Type Error Feedback via Analytic Program Repair}, year = {2020}, isbn = {9781450376136}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/3385412.3386005}, doi = {10.1145/3385412.3386005}, booktitle = {Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation}, pages = {16–30}, numpages = {15}, keywords = {Program Synthesis, Machine Learning, Program Repair, Type Error Feedback}, location = {London, UK}, series = {PLDI 2020}} @article{seidel2017learn, author = {Seidel, Eric L. and Sibghat, Huma and Chaudhuri, Kamalika and Weimer, Westley and Jhala, Ranjit}, title = {Learning to Blame: Localizing Novice Type Errors with Data-Driven Diagnosis}, year = {2017}, issue_date = {October 2017}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {1}, number = {OOPSLA}, url = {https://doi.org/10.1145/3138818}, doi = {10.1145/3138818}, journal = {Proc. ACM Program. Lang.}, month = {oct}, articleno = {60}, numpages = {27}, keywords = {type errors, fault localization}} @inproceedings{senay1991logic, author = {H. Senay and S. Lazzeri}, booktitle = {Proceedings 1991 IEEE Workshop on Visual Languages}, title = {Graphical representation of logic programs and their behaviour}, year = {1991}, volume = {}, issn = {}, pages = {25,26,27,28,29,30,31}, keywords = {logic programming;debugging;tree graphs;couplings;programming profession;switches;logic design;programming environments;computerized monitoring;computer languages}, doi = {10.1109/WVL.1991.238854}, url = {https://doi.ieeecomputersociety.org/10.1109/WVL.1991.238854}, publisher = {IEEE Computer Society}, address = {Los Alamitos, CA, USA}, month = {oct}} @book{shapiroaadebug, author = {Shapiro, Ehud Yehuda}, title = {Algorithmic program debugging}, year = {1982}, publisher = {Yale University}, address = {USA}, abstract = {The thesis lays a theoretical framework for program debugging, with the goal of partly mechanizing this activity. In particular, we formalize and develop algorithmic solutions to the following two questions: (1) How do we identify a bug in a program that behaves incorrectly__ __ (2) How do we fix a bug, once one is identified__ __ We develop interactive diagnosis algorithms that identify a bug in a program that behaves incorrectly, and implement them in Prolog for the diagnosis of Prolog programs. Their performance suggests that they can be the backbone of debugging aids that go far beyond what is offered by current programming environments.We develop an inductive inference algorithm that synthesizes logic programs from examples of their behavior. The algorithm incorporates the diagnosis algorithms as a component. It is incremental, and progresses by debugging a program with respect to the examples. The Model Inference System is a Prolog implementation of the algorithm. Its range of applications and efficiency is comparable to existing systems for program synthesis from examples and grammatical inference.We develop an algorithm that can fix a bug that has been identified, and integrate it with the diagnosis algorithms to form an interactive debugging system. By restricting the class of bugs we attempt to correct, the system can debug programs that are too complex for the Model Inference System to synthesize.}, note = {AAI8221751}} @inproceedings{shi2023tactic, author = {Shi, Jessica and Pierce, Benjamin and Head, Andrew}, title = {Towards a Science of Interactive Proof Reading}, year = {2023}, booktitle = {Proceedings of the 13th Annual Workshop on the Intersection of HCI and PL}, series = {PLATEAU '23}} @book{sterlingshapiroart1994, author = {Sterling, Leon and Shapiro, Ehud}, title = {The art of Prolog (2nd ed.): advanced programming techniques}, year = {1994}, isbn = {0262193388}, publisher = {MIT Press}, address = {Cambridge, MA, USA}} @misc{strachey67, AUTHOR = {Strachey, Christopher}, TITLE = {Fundamental Concepts in Programming Languages}, HOWPUBLISHED = {Lecture Notes, International Summer School in Computer Programming, Copenhagen}, MONTH = AUG, YEAR = {1967}, NOTE = {Reprinted in {\em Higher-Order and Symbolic Computation}, 13(1/2), pp. 1--49, 2000}} @inproceedings{stuckey2003chameleon, author = {Stuckey, Peter J. and Sulzmann, Martin and Wazny, Jeremy}, title = {Interactive Type Debugging in Haskell}, year = {2003}, isbn = {1581137583}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/871895.871903}, doi = {10.1145/871895.871903}, booktitle = {Proceedings of the 2003 ACM SIGPLAN Workshop on Haskell}, pages = {72–83}, numpages = {12}, keywords = {overloading, constraints, type debugging, Hindley/Milner, type classes, type inference}, location = {Uppsala, Sweden}, series = {Haskell '03}} @misc{coq-refman, title = "The {Coq} Reference Manual -- Release 8.18.0", author = "{The Coq Development Team}", year = "2023", howpublished = "\url{https://coq.inria.fr/doc/V8.18.0/refman}"} @misc{coqprooftree, author = {Tews, Hendrik }, title = {ProofTree}, year = {2011}, publisher = {GitHub}, journal = {GitHub repository}, howpublished = {\url{https://github.com/hendriktews/proof-tree}},} @inproceedings{asai2013embedded, author="Tsushima, Kanae and Asai, Kenichi", editor="Hinze, Ralf", title="An Embedded Type Debugger", booktitle="Implementation and Application of Functional Languages", year="2013", publisher="Springer Berlin Heidelberg", address="Berlin, Heidelberg", pages="190--206", abstract="This paper presents how to build a type debugger without implementing any dedicated type inferencer. Previous type debuggers required their own type inferencers apart from the compiler's type inferencer. The advantage of our approach is threefold. First, by not implementing a type inferencer, it is guaranteed that the debugger's type inference never disagrees with the compiler's type inference. Secondly, we can avoid the pointless reproduction of a type inferencer that should work precisely as the compiler's type inferencer. Thirdly, our approach is robust to updates of the underlying language. The key observation of our approach is that the interactive type debugging, as proposed by Chitil, does not require a type inference tree but only a tree with a certain simple property. We identify the property and present how to construct a tree that satisfies this property using the compiler's type inferencer. The property guides us how to build a type debugger for various language constructs. In this paper, we describe our idea and first apply it to the simply-typed lambda calculus. After that, we extend it with let-polymorphism and objects to see how our technique scales.", isbn="978-3-642-41582-1"} @inproceedings{wadlerblott1989classes, author = {Wadler, P. and Blott, S.}, title = {How to make ad-hoc polymorphism less ad hoc}, year = {1989}, isbn = {0897912942}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/75277.75283}, doi = {10.1145/75277.75283}, abstract = {This paper presents type classes, a new approach to ad-hoc polymorphism. Type classes permit overloading of arithmetic operators such as multiplication, and generalise the “eqtype variables” of Standard ML. Type classes extend the Hindley/Milner polymorphic type system, and provide a new approach to issues that arise in object-oriented programming, bounded type quantification, and abstract data types. This paper provides an informal introduction to type classes, and defines them formally by means of type inference rules.}, booktitle = {Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages}, pages = {60–76}, numpages = {17}, location = {Austin, Texas, USA}, series = {POPL '89}} @inproceedings{wand1986findingte, author = {Wand, Mitchell}, title = {Finding the Source of Type Errors}, year = {1986}, isbn = {9781450373470}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/512644.512648}, doi = {10.1145/512644.512648}, booktitle = {Proceedings of the 13th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages}, pages = {38–43}, numpages = {6}, location = {St. Petersburg Beach, Florida}, series = {POPL '86}} @article{meyers2014generaldiagnosis, author = {Zhang, Danfeng and Myers, Andrew C.}, title = {Toward General Diagnosis of Static Errors}, year = {2014}, issue_date = {January 2014}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {49}, number = {1}, issn = {0362-1340}, url = {https://doi.org/10.1145/2578855.2535870}, doi = {10.1145/2578855.2535870}, journal = {SIGPLAN Not.}, month = {jan}, pages = {569–581}, numpages = {13}, keywords = {type inference, information flow, error diagnosis, static program analysis}} @article{zhang2017sherrloc, author = {Zhang, Danfeng and Myers, Andrew C. and Vytiniotis, Dimitrios and Peyton-Jones, Simon}, title = {SHErrLoc: A Static Holistic Error Locator}, year = {2017}, issue_date = {December 2017}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, volume = {39}, number = {4}, issn = {0164-0925}, url = {https://doi.org/10.1145/3121137}, doi = {10.1145/3121137}, journal = {ACM Trans. Program. Lang. Syst.}, month = {aug}, articleno = {18}, numpages = {47}, keywords = {information flow, OCaml, type inference, Error diagnosis, static program analysis, Haskell, Jif}} @inproceedings{meyers2015class, author = {Zhang, Danfeng and Myers, Andrew C. and Vytiniotis, Dimitrios and Peyton-Jones, Simon}, title = {Diagnosing Type Errors with Class}, year = {2015}, isbn = {9781450334686}, publisher = {Association for Computing Machinery}, address = {New York, NY, USA}, url = {https://doi.org/10.1145/2737924.2738009}, doi = {10.1145/2737924.2738009}, booktitle = {Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation}, pages = {12–21}, numpages = {10}, keywords = {Error diagnosis, type inference, Haskell}, location = {Portland, OR, USA}, series = {PLDI '15}}