Simply RaTT: a fitch-style modal calculus for reactive programming without space leaks

Bahr, Patrick; Graulund, Christian Uldal; Møgelberg, Rasmus Ejlers

doi:10.1145/3341713

Cited by 18 publications

(61 citation statements)

References 23 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The lack of an inclusion from ▷ to ⃝ means that there is no inclusion ▷ → to take a fixed point of to construct a diverging element of . To make these ideas concrete we define the language Lively RaTT (section 2) as an extension of the language Simply RaTT [Bahr et al 2019]. Simply RaTT is an FRP language with modal operators ▷ and □ as described above, as well as guarded recursive types and guarded fixed points.…”

Section: Overview Of Resultsmentioning

confidence: 99%

“…More recently, a number of authors [Bahr et al 2019;Jeffrey 2014;Jeltsch 2013;Krishnaswami 2013;Krishnaswami and Benton 2011;Krishnaswami et al 2012] have suggested a modal approach to FRP in which causality is ensured through the introduction of a notion of time in the form of a modal operator. In this approach, an element of the modal type ▷ should be thought of as data of type arriving in the next time step.…”

Section: Introductionmentioning

confidence: 99%

“…the property that for a closed stream, each of its elements can always be computed in finite time. In some systems [Bahr et al 2019;Krishnaswami 2013;Krishnaswami et al 2012] the modal types have also been used to guarantee the lack of implicit space leaks, i.e., the problem of programs holding on to memory while continually allocating until they run out of space. These leaks have previously been a major problem in FRP.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Diamonds are not forever: liveness in reactive programming with guarded recursion

Bahr

Graulund

Møgelberg

2021

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

When designing languages for functional reactive programming (FRP) the main challenge is to provide the user with a simple, flexible interface for writing programs on a high level of abstraction while ensuring that all programs can be implemented efficiently in a low-level language. To meet this challenge, a new family of modal FRP languages has been proposed, in which variants of Nakano's guarded fixed point operator are used for writing recursive programs guaranteeing properties such as causality and productivity. As an apparent extension to this it has also been suggested to use Linear Temporal Logic (LTL) as a language for reactive programming through the Curry-Howard isomorphism, allowing properties such as termination, liveness and fairness to be encoded in types. However, these two ideas are in conflict with each other, since the fixed point operator introduces non-termination into the inductive types that are supposed to provide termination guarantees. In this paper we show that by regarding the modal time step operator of LTL a submodality of the one used for guarded recursion (rather than equating them), one can obtain a modal type system capable of expressing liveness properties while retaining the power of the guarded fixed point operator. We introduce the language Lively RaTT, a modal FRP language with a guarded fixed point operator and an `until' type constructor as in LTL, and show how to program with events and fair streams. Using a step-indexed Kripke logical relation we prove operational properties of Lively RaTT including productivity and causality as well as the termination and liveness properties expected of types from LTL. Finally, we prove that the type system of Lively RaTT guarantees the absence of implicit space leaks.

show abstract

Section: Overview Of Resultsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Diamonds are not forever: liveness in reactive programming with guarded recursion

Bahr

Graulund

Møgelberg

2021

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

show abstract

“…This ensures that it is safe to propagate signals past all enveloping interrupt handlers, and communicate their payloads to other processes. In its essence, this is similar to the use of modal types in distributed [Murphy VII 2008] and reactive programming [Bahr et al 2019;Krishnaswami 2013] to classify values that can travel through space and time. In our case, it is the omission of promise types from ground types that allows us to consider the payloads of signals and interrupts as such mobile values.…”

Section: Resultsmentioning

confidence: 99%

Asynchronous effects

Ahman

Pretnar

2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

We explore asynchronous programming with algebraic effects. We complement their conventional synchronous treatment by showing how to naturally also accommodate asynchrony within them, namely, by decoupling the execution of operation calls into signalling that an operation’s implementation needs to be executed, and interrupting a running computation with the operation’s result, to which the computation can react by installing interrupt handlers. We formalise these ideas in a small core calculus, called λ æ . We demonstrate the flexibility of λ æ using examples ranging from a multi-party web application, to preemptive multi-threading, to remote function calls, to a parallel variant of runners of algebraic effects. In addition, the paper is accompanied by a formalisation of λ æ ’s type safety proofs in Agda, and a prototype implementation of λ æ in OCaml.

show abstract

“…Another technique stipulates that modalities are essentially right adjoints, with the corresponding left adjoints being constructors on contexts. These Fitch-style type theories [10,11,14,20,30] are relatively simple, which has made them convenient for programming applications [11,30]. Nevertheless, scaling this approach to a multimodal setting has proven difficult.…”

Section: Related Workmentioning

confidence: 99%

Multimodal Dependent Type Theory

Gratzer

Kavvos

Nuyts

et al. 2020

Proceedings of the 35th Annual ACM/IEEE Symposium on Logic in Computer Science

View full text Add to dashboard Cite

We introduce MTT, a dependent type theory which supports multiple modalities. MTT is parametrized by a mode theory which specifies a collection of modes, modalities, and transformations between them. We show that different choices of mode theory allow us to use the same type theory to compute and reason in many modal situations, including guarded recursion, axiomatic cohesion, and parametric quantification. We reproduce examples from prior work in guarded recursion and axiomatic cohesion-demonstrating that MTT constitutes a simple and usable syntax whose instantiations intuitively correspond to previous handcrafted modal type theories. In some cases, instantiating MTT to a particular situation unearths a previously unknown type theory that improves upon prior systems. Finally, we investigate the metatheory of MTT. We prove the consistency of MTT and establish canonicity through an extension of recent type-theoretic gluing techniques. These results hold irrespective of the choice of mode theory, and thus apply to a wide variety of modal situations.

show abstract

Simply RaTT: a fitch-style modal calculus for reactive programming without space leaks

Cited by 18 publications

References 23 publications

Diamonds are not forever: liveness in reactive programming with guarded recursion

Diamonds are not forever: liveness in reactive programming with guarded recursion

Asynchronous effects

Multimodal Dependent Type Theory

Contact Info

Product

Resources

About