Theoretical Computer Science
SIGNAL: A declarative language for synchronous programming of real-time systems
Proc. of a conference on Functional programming languages and computer architecture
CLEAN: A language for functional graph rewriting
Proc. of a conference on Functional programming languages and computer architecture
LUSTRE: a declarative language for real-time programming
POPL '87 Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Computational lambda-calculus and monads
Proceedings of the Fourth Annual Symposium on Logic in computer science
Is there a use for linear logic?
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Report on the programming language Haskell: a non-strict, purely functional language version 1.2
ACM SIGPLAN Notices - Haskell special issue
The essence of functional programming
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Imperative functional programming
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
PLDI '94 Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation
TBAG: a high level framework for interactive, animated 3D graphics applications
SIGGRAPH '94 Proceedings of the 21st annual conference on Computer graphics and interactive techniques
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
The Haskell school of expression: learning functional programming through multimedia
The Haskell school of expression: learning functional programming through multimedia
Science of Computer Programming - Special issue on mathematics of program construction
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
The ESTEREL Synchronous Programming Language and its Mathematical Semantics
Seminar on Concurrency, Carnegie-Mellon University
Haskell '03 Proceedings of the 2003 ACM SIGPLAN workshop on Haskell
Strongly typed heterogeneous collections
Haskell '04 Proceedings of the 2004 ACM SIGPLAN workshop on Haskell
Plugging a Space Leak with an Arrow
Electronic Notes in Theoretical Computer Science (ENTCS)
Integrating dataflow evaluation into a practical higher-order call-by-value language
Integrating dataflow evaluation into a practical higher-order call-by-value language
Journal of Functional Programming
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Nettle: taking the sting out of programming network routers
PADL'11 Proceedings of the 13th international conference on Practical aspects of declarative languages
Higher-order functional reactive programming in bounded space
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
PLPV '12 Proceedings of the sixth workshop on Programming languages meets program verification
TLDI '12 Proceedings of the 8th ACM SIGPLAN workshop on Types in language design and implementation
Journal of Functional Programming - Dedicated to ICFP 2009
Embedding dynamic dataflow in a call-by-value language
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
Virtualizing real-world objects in FRP
PADL'12 Proceedings of the 14th international conference on Practical Aspects of Declarative Languages
Hi-index | 0.00 |
Functional reactive programming (FRP) is a useful model for programming real-time and reactive systems in which one defines a signal function to process a stream of input values into a stream of output values. However, performing side effects (e.g. memory mutation or input/output) in this model is tricky and typically unsafe. In previous work, Winograd-Cort et al. [2012] introduced resource types and wormholes to address this problem. This paper better motivates, expands upon, and formalizes the notion of a wormhole to fully unlock its potential. We show, for example, that wormholes can be used to define the concept of causality. This in turn allows us to provide behaviors such as looping, a core component of most languages, without building it directly into the language. We also improve upon our previous design by making wormholes less verbose and easier to use. To formalize the notion of a wormhole, we define an extension to the simply typed lambda calculus, complete with typing rules and operational semantics. In addition, we present a new form of semantic transition that we call a temporal transition to specify how an FRP program behaves over time and to allow us to better reason about causality. As our model is designed for a Haskell implementation, the semantics are lazy. Finally, with the language defined, we prove that our wormholes indeed allow side effects to be performed safely in an FRP framework.