Abstract continuations: a mathematical semantics for handling full jumps
LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Scheme and the art of programming
Scheme and the art of programming
Computational lambda-calculus and monads
Proceedings of the Fourth Annual Symposium on Logic in computer science
A formulae-as-type notion of control
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Monads and composable continuations
Lisp and Symbolic Computation
The discoveries of continuations
Lisp and Symbolic Computation - Special issue on continuations—part I
The seasoned Schemer
Concurrent programming in ML
CPS translating inductive and coinductive types
PEPM '02 Proceedings of the 2002 ACM SIGPLAN workshop on Partial evaluation and semantics-based program manipulation
Continuations: A Mathematical Semantics for Handling FullJumps
Higher-Order and Symbolic Computation
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Concurrency and Automata on Infinite Sequences
Proceedings of the 5th GI-Conference on Theoretical Computer Science
Local Reasoning about Programs that Alter Data Structures
CSL '01 Proceedings of the 15th International Workshop on Computer Science Logic
Interactive Theorem Proving and Program Development
Interactive Theorem Proving and Program Development
A complete, co-inductive syntactic theory of sequential control and state
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A compositional natural semantics and Hoare logic for low-level languages
Theoretical Computer Science
Combining algebraic effects with continuations
Theoretical Computer Science
Hoare type theory, polymorphism and separation1
Journal of Functional Programming
Journal of Functional Programming
ESOP '09 Proceedings of the 18th European Symposium on Programming Languages and Systems: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
A Hoare Logic for the State Monad
TPHOLs '09 Proceedings of the 22nd International Conference on Theorem Proving in Higher Order Logics
Computational Effects and Operations: An Overview
Electronic Notes in Theoretical Computer Science (ENTCS)
Structuring the verification of heap-manipulating programs
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The implicit calculus of constructions as a programming language with dependent types
FOSSACS'08/ETAPS'08 Proceedings of the Theory and practice of software, 11th international conference on Foundations of software science and computational structures
The impact of higher-order state and control effects on local relational reasoning
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Partiality, state and dependent types
TLCA'11 Proceedings of the 10th international conference on Typed lambda calculi and applications
Program logics for sequential higher-order control
FSEN'09 Proceedings of the Third IPM international conference on Fundamentals of Software Engineering
A compositional logic for control flow
VMCAI'06 Proceedings of the 7th international conference on Verification, Model Checking, and Abstract Interpretation
High-level separation logic for low-level code
POPL '13 Proceedings of the 40th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Verifying higher-order programs with the dijkstra monad
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
Verifying higher-order imperative programs with higher-order separation logic
Verifying higher-order imperative programs with higher-order separation logic
| Hi-index | 0.00 |
Continuations are programming abstractions that allow for manipulating the "future" of a computation. Amongst their many applications, they enable implementing unstructured program flow through higher-order control operators such as callcc. In this paper we develop a Hoare-style logic for the verification of programs with higher-order control, in the presence of dynamic state. This is done by designing a dependent type theory with first class callcc and abort operators, where pre- and postconditions of programs are tracked through types. Our operators are algebraic in the sense of Plotkin and Power, and Jaskelioff, to reduce the annotation burden and enable verification by symbolic evaluation. We illustrate working with the logic by verifying a number of characteristic examples.