PLDI '94 Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation
An indexed model of recursive types for foundational proof-carrying code
ACM Transactions on Programming Languages and Systems (TOPLAS)
Computational Adequacy via "Mixed" Inductive Definitions
Proceedings of the 9th International Conference on Mathematical Foundations of Programming Semantics
Codifying Guarded Definitions with Recursive Schemes
TYPES '94 Selected papers from the International Workshop on Types for Proofs and Programs
LICS '00 Proceedings of the 15th Annual IEEE Symposium on Logic in Computer Science
Monadic encapsulation of effects: a revised approach (extended version)
Journal of Functional Programming
Applicative programming with effects
Journal of Functional Programming
A semantic model for graphical user interfaces
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
Ultrametric Semantics of Reactive Programs
LICS '11 Proceedings of the 2011 IEEE 26th Annual Symposium on Logic in Computer Science
Pure type systems with corecursion on streams: from finite to infinitary normalisation
Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
The recursive polarized dual calculus
Proceedings of the ACM SIGPLAN 2014 Workshop on Programming Languages meets Program Verification
Hi-index | 0.00 |
Total functional programming offers the beguiling vision that, just by virtue of the compiler accepting a program, we are guaranteed that it will always terminate. In the case of programs that are not intended to terminate, e.g., servers, we are guaranteed that programs will always be productive. Productivity means that, even if a program generates an infinite amount of data, each piece will be generated in finite time. The theoretical underpinning for productive programming with infinite output is provided by the category theoretic notion of final coalgebras. Hence, we speak of coprogramming with non-well-founded codata, as a dual to programming with well-founded data like finite lists and trees. Systems that offer facilities for productive coprogramming, such as the proof assistants Coq and Agda, currently do so through syntactic guardedness checkers. Syntactic guardedness checkers ensure that all self-recursive calls are guarded by a use of a constructor. Such a check ensures productivity. Unfortunately, these syntactic checks are not compositional, and severely complicate coprogramming. Guarded recursion, originally due to Nakano, is tantalising as a basis for a flexible and compositional type-based approach to coprogramming. However, as we show, by itself, guarded recursion is not suitable for coprogramming due to the fact that there is no way to make finite observations on pieces of infinite data. In this paper, we introduce the concept of clock variables that index Nakano's guarded recursion. Clock variables allow us to "close over" the generation of infinite data, and to make finite observations, something that is not possible with guarded recursion alone.