Proof of Programs with Effect Handlers
Preuves de Programmes avec Effect Handlers
Résumé
This thesis addresses the problem of reasoning about programs that modify the heap and alter the control flow through effect handlers, a novel programming construct that provides a relatively simple interface to delimited control. This ability to manipulate the control flow is extremely powerful: many programming features -- such as asynchronous programming and coroutines -- that come as built-in packages of traditional programming languages can be expressed in terms of effect handlers. The status of effect handlers as a modular and expressive programming construct is attested by the development of the OCaml programming language, which will have support for handlers in its next major release. This event makes the problem of unveiling the logical principles that govern effect handlers even more pressing. In particular, how to reason abstractly about a continuation, rather than thinking concretely as a fragment of the stack? Moreover, can we reason separately about a program that performs effects and a program that handles these effects? This thesis answers these questions by introducing Hazel, a Separation Logic for effect handlers, built as an extension of Iris. Hazel introduces a novel specification language by means of which one can describe the behavior of programs, including continuations. The logic allows one to compose specifications in a modular fashion through familiar reasoning rules, such as the bind rule and the frame rule, and through novel ones, such as the reasoning rules for handling and performing effects. To assess the applicability of Hazel as a tool to formally reason about programs, this thesis includes the verification of a number of case studies: (1) a program that transforms a higher-order iteration method into a lazy sequence; (2) a library for asynchronous computation; and (3) a library for reverse-mode automatic differentiation. This thesis also explores variants of the Hazel logic for different languages in the design space of effect handlers. One such variant, for example, is Maze, a logic for handlers with multi-shot continuations, ie, continuations that can be resumed multiple times. The applicability of Maze is assessed through the verification of a simple SAT solver that uses multi-shot continuations to implement backtracking and through the design of reasoning rules for the undelimited-control operators callcc and throw. Another variant is TesLogic, a logic for a language with support for the dynamic generation of effect labels, identifiers used by both a program that performs effects and a program that handles effects as a way to specify the correspondence between these two programs. The main application of TesLogic is in the study of type systems for effect handlers. The question of devising a static type discipline for effect handlers is the subject of an open debate, which seems to suggest a dichotomy: in order to achieve simple and strong subtyping rules, one side argues in favor of imposing a restriction to lexically scoped handlers, while the other side argues in favor of complex programming constructs, such as effect coercions. This thesis makes a contribution to this debate by introducing Tes, a type system that is not restricted to lexically scoped handlers, and that supports powerful subtyping rules without the introduction of effect coercions. The soundness of Tes follows from the interpretation of typing judgments as specifications written in TesLogic. The results of this thesis have been formalized in the Coq Proof Assistant.
Cette thèse s'intéresse à la conception de méthodes formelles pour raisonner sur les programmes impératifs qui peuvent modifier le flot de contrôle à travers les gestionnaires d'effets, une nouvelle primitive de programmation offrant une interface relativement simple aux opérateurs de contrôle délimité. Les gestionnaires d'effets sont extrêmement puissants en tant qu'outil de programmation: plusieurs primitives et modes de programmation -- comme la programmation asynchrone -- souvent considérés dans les langages traditionnels comme des parties intégrées de ces langages peuvent être implémentés à l'aide des gestionnaires d'effets. La réputation des gestionnaires d'effets en tant que concept de programmation puissant et modulaire est attestée par le développement du langage OCaml, qui offrira les gestionnaires d'effets dans sa prochaine version majeure. Cet événement fait de la recherche des principes logiques qui sous-tendent les gestionnaires d'effets un problème encore plus pressant. En particulier, comment peut-on raisonner à propos d'une continuation de façon abstraite plutôt que de façon concrète comme un morceau de la pile d'exécution? Comment peut-on raisonner à propos d'un programme qui lance des effets séparément du programme qui attrape ces effets? Cette thèse répond à ces questions en introduisant Hazel, une Logique de Séparation pour les gestionnaires d'effets. Hazel introduit un nouveau langage de spécification permettant la description du comportement des programmes, y compris des continuations. Cette logique permet aussi la composition des spécifications de façon modulaire, soit par l'application de règles de raisonnement habituelles, tel que la règle de liaison ou la règle de l'encadrement; soit par l'application de règles nouvelles, comme les règles pour lancer ou capturer des effets. Pour évaluer l'applicabilité de Hazel en tant qu'outil pour le raisonnement formel sur les programmes, cette thèse inclut la vérification de nombreux cas d'études: (1) la conversion générique d'une méthode d'itération d'ordre supérieur en une séquence paresseuse; (2) une bibliothèque pour la programmation asynchrone; (3) une bibliothèque pour la différentiation automatique en arrière. Cette thèse étudie aussi des variantes de Hazel pour les différentes conceptions de gestionnaires d'effets. Parmi ces variantes se trouve Maze, une logique pour les gestionnaires d'effets avec des continuations à plusieurs appels (multi-shot). L'applicabilité de Maze est évaluée par (1) la vérification d'un solveur SAT simple qui utilise des continuations pour implémenter le rebroussement et par (2) la conception de règles de raisonnement pour call/cc et throw. Une autre variante est TesLogic, une logique pour raisonner sur la génération dynamique de noms d'effets. La principale application de TesLogic est l'étude des systèmes de types pour les gestionnaires d'effets. La conception d'un système de types pour les gestionnaires d'effets est le sujet d'un débat actif: pour offrir des règles simples et permissives de sous-typage, un côté soutient la restriction des gestionnaires d'effets aux gestionnaires d'effets de portée lexicale, tandis que l'autre côté soutient l'adoption de coercions d'effets. Cette thèse contribue à ce débat en introduisant Tes, un système de types qui (1) n'est pas restreint aux gestionnaires d'effets de portée lexicale, (2) n'introduit pas de coercions d'effets, et (3) admet des règles de sous-typage puissantes. La sûreté de Tes est prouvée à l'aide d'une interprétation des jugements de typage en tant que spécifications écrites en TesLogic. Les résultats de cette thèse sont formalisés dans l'assistant de preuve Coq.
| Origine | Version validée par le jury (STAR) |
|---|