Standard

Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study. / Devriese, Dominique.

Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell. New York, NY, USA : ACM, 2019. p. 1-14 (Haskell 2019).

Research output: Chapter in Book/Report/Conference proceedingConference paper

Harvard

Devriese, D 2019, Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study. in Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell. Haskell 2019, ACM, New York, NY, USA, pp. 1-14, 12th ACM SIGPLAN International Haskell Symposium, Berlin, Germany, 22/08/19. https://doi.org/10.1145/3331545.3342589

APA

Devriese, D. (2019). Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study. In Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell (pp. 1-14). (Haskell 2019). New York, NY, USA: ACM. https://doi.org/10.1145/3331545.3342589

Vancouver

Devriese D. Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study. In Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell. New York, NY, USA: ACM. 2019. p. 1-14. (Haskell 2019). https://doi.org/10.1145/3331545.3342589

Author

Devriese, Dominique. / Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study. Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell. New York, NY, USA : ACM, 2019. pp. 1-14 (Haskell 2019).

BibTeX

@inproceedings{a9e21cc2547f4c9f8b111b570081cab2,
title = "Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study",
abstract = "In applications with a complex structure of side-effects, effects should be dealt with modularly: components should be programmed against abstract effect interfaces that other components can instantiate as required, and reusable effect patterns should be factored out from the rest of the application. In this paper, we study a new, general approach to achieve this in Haskell by combining effect polymorphism and the recently proposed coherent explicit dictionary applications. We demonstrate the elegance and generality of our approach in μVeriFast: a Haskell-based reimplementation of the semi-automatic separation-logic-based verification tool VeriFast. This implementation features a complex interplay of advanced side-effects: a backtracking search of program paths with angelic and demonic non-determinism, interaction with an underlying off-the-shelf SMT solver, and mutable state that is either backtracked or not during the search. Our use of effect polymorphism improves over the current non-modular implementation of VeriFast, allows us to nicely factor out the backtracking search pattern as a new AssumeAssert monad, and enables advanced features involving effects, such as the non-intrusive addition of a graphical symbolic debugger based on delimited continuations.",
keywords = "Haskell, backtracking search, effect polymorphism, modular effects, monads, separation logic, symbolic execution",
author = "Dominique Devriese",
year = "2019",
doi = "10.1145/3331545.3342589",
language = "English",
isbn = "978-1-4503-6813-1",
series = "Haskell 2019",
publisher = "ACM",
pages = "1--14",
booktitle = "Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell",

}

RIS

TY - GEN

T1 - Modular Effects in Haskell Through Effect Polymorphism and Explicit Dictionary Applications: A New Approach and the μVeriFast Verifier As a Case Study

AU - Devriese, Dominique

PY - 2019

Y1 - 2019

N2 - In applications with a complex structure of side-effects, effects should be dealt with modularly: components should be programmed against abstract effect interfaces that other components can instantiate as required, and reusable effect patterns should be factored out from the rest of the application. In this paper, we study a new, general approach to achieve this in Haskell by combining effect polymorphism and the recently proposed coherent explicit dictionary applications. We demonstrate the elegance and generality of our approach in μVeriFast: a Haskell-based reimplementation of the semi-automatic separation-logic-based verification tool VeriFast. This implementation features a complex interplay of advanced side-effects: a backtracking search of program paths with angelic and demonic non-determinism, interaction with an underlying off-the-shelf SMT solver, and mutable state that is either backtracked or not during the search. Our use of effect polymorphism improves over the current non-modular implementation of VeriFast, allows us to nicely factor out the backtracking search pattern as a new AssumeAssert monad, and enables advanced features involving effects, such as the non-intrusive addition of a graphical symbolic debugger based on delimited continuations.

AB - In applications with a complex structure of side-effects, effects should be dealt with modularly: components should be programmed against abstract effect interfaces that other components can instantiate as required, and reusable effect patterns should be factored out from the rest of the application. In this paper, we study a new, general approach to achieve this in Haskell by combining effect polymorphism and the recently proposed coherent explicit dictionary applications. We demonstrate the elegance and generality of our approach in μVeriFast: a Haskell-based reimplementation of the semi-automatic separation-logic-based verification tool VeriFast. This implementation features a complex interplay of advanced side-effects: a backtracking search of program paths with angelic and demonic non-determinism, interaction with an underlying off-the-shelf SMT solver, and mutable state that is either backtracked or not during the search. Our use of effect polymorphism improves over the current non-modular implementation of VeriFast, allows us to nicely factor out the backtracking search pattern as a new AssumeAssert monad, and enables advanced features involving effects, such as the non-intrusive addition of a graphical symbolic debugger based on delimited continuations.

KW - Haskell

KW - backtracking search

KW - effect polymorphism

KW - modular effects

KW - monads

KW - separation logic

KW - symbolic execution

U2 - 10.1145/3331545.3342589

DO - 10.1145/3331545.3342589

M3 - Conference paper

SN - 978-1-4503-6813-1

T3 - Haskell 2019

SP - 1

EP - 14

BT - Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell

PB - ACM

CY - New York, NY, USA

ER -

ID: 46792706