Eric Zhao Raef Maroof Anand Dukkipati Andrew Blinn Zhiyi Pan Cyrus Omar 2023 2022 https://mustardfox.org/zzhaoe-000B/ zzhaoe-000B /zzhaoe-000B/ Total Type Error Localization and Recovery with Holes (Agda) software 10.5281/zenodo.10129703 POPL 2024 hazelgrove/error-localization-agda An Agda mechanization of the marked lambda calculus, a judgmental framework for bidirectional type error localization and recovery described in "Total Type Error Localization and Recovery with Holes". References Context Backlinks Related 2024 1 14 2024 1 20 https://mustardfox.org/popl-2024/ popl-2024 /popl-2024/ POPL 2024 venue https://popl24.sigplan.org London, United Kingdom Eric Zhao Raef Maroof Anand Dukkipati Andrew Blinn Zhiyi Pan Cyrus Omar 2024 1 5 https://mustardfox.org/zhao-et-al-2024/ zhao-et-al-2024 /zhao-et-al-2024/ Total Type Error Localization and Recovery with Holes reference 10.1145/3632910 POPL 2024 /bafkrmig6uouiljzl7bd2hsdvybslotw4hme5ee2wrptjxfu243y2zskscu.pdf /bafkrmicqbx7k3zk2yw3wouzg7xccmly4fj422zl2ixpx5uozuxrmpswnrm.pdf zzhaoe-000B Eric Zhao Raef Maroof Anand Dukkipati Andrew Blinn Zhiyi Pan Cyrus Omar 2024 1 5 abstract Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e. the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel. Contributions