Rhine: FRP with type-level clocks

Bärenz, Manuel; Perez, Ivan

doi:10.1145/3242744.3242757

Cited by 16 publications

(5 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…[23]. Rhine [7] is a recent refinement of Yampa that annotates signal functions with type-level clocks, which allows the construction of complex dataflow graphs that combine subsystems running at different clock speeds. The typing discipline fixes the clock of each subsystem statically at compile time, since the aim of Rhine is provide efficient resampling between subsystems.…”

Section: Related Workmentioning

confidence: 99%

Asynchronous Modal FRP

Bahr¹,

Møgelberg²

2023

Preprint

View full text Add to dashboard Cite

Over the past decade, a number of languages for functional reactive programming (FRP) have been suggested, which use modal types to ensure properties like causality, productivity and lack of space leaks. So far, almost all of these languages have included a modal operator for delay on a global clock. For some applications, however, the notion of global clock is unnatural and leads to leaky abstractions as well as inefficient implementations. While modal languages without a global clock have been proposed, no operational properties have been proved about them, yet.This paper proposes Async RaTT, a new modal language for asynchronous FRP, equipped with an operational semantics mapping complete programs to machines that take asynchronous input signals and produce output signals. The main novelty of Async RaTT is a new modality for asynchronous delay, allowing each output channel to be associated at runtime with the set of input channels it depends on, thus causing the machine to only compute new output when necessary. We prove a series of operational properties including causality, productivity and lack of space leaks. We also show that, although the set of input channels associated with an output channel can change during execution, upper bounds on these can be determined statically by the type system.

show abstract

Section: Related Workmentioning

confidence: 99%

Asynchronous Modal FRP

Bahr¹,

Møgelberg²

2023

Preprint

View full text Add to dashboard Cite

show abstract

“…Hailstorm, in the presence of recursion, is unable to statically predict memory usage but we plan future work on type level encoding of buffer sizes to make memory usage more predictable. Polychronous languages like SIGNAL [8] and FRP libraries like Rhine [6] provide static guarantees on correctness of systems with multiple clocks -something that we hope to experiment with in the future.…”

Section: Related Work 61 Programming Languages For Iotmentioning

confidence: 99%

Hailstorm: A Statically-Typed, Purely Functional Language for IoT Applications

Sarkar

Sheeran

2020

Proceedings of the 22nd International Symposium on Principles and Practice of Declarative Programming

View full text Add to dashboard Cite

With the growing ubiquity of Internet of Things (IoT), more complex logic is being programmed on resource-constrained IoT devices, almost exclusively using the C programming language. While C provides low-level control over memory, it lacks a number of highlevel programming abstractions such as higher-order functions, polymorphism, strong static typing, memory safety, and automatic memory management. We present Hailstorm, a statically-typed, purely functional programming language that attempts to address the above problem. It is a high-level programming language with a strict typing discipline. It supports features like higher-order functions, tail-recursion, and automatic memory management, to program IoT devices in a declarative manner. Applications running on these devices tend to be heavily dominated by I/O. Hailstorm tracks side effects like I/O in its type system using resource types. This choice allowed us to explore the design of a purely functional standalone language, in an area where it is more common to embed a functional core in an imperative shell. The language borrows the combinators of arrowized FRP, but has discrete-time semantics. The design of the full set of combinators is work in progress, driven by examples. So far, we have evaluated Hailstorm by writing standard examples from the literature (earthquake detection, a railway crossing system and various other clocked systems), and also running examples on the GRiSP embedded systems board, through generation of Erlang. CCS CONCEPTS • Software and its engineering → Compilers; Domain specific languages; • Computer systems organization → Sensors and actuators; Embedded software.

show abstract

“…From the point of view of the user, a change in the clock rate will imply both that the physics simulation is more accurate, and that the computers are sampling (and correcting) more frequently, but not necessarily help explain which one is at fault. The use of different clocks for FRP simulations and their correct coordination has been the subject of study of Bärenz & Perez (2018). Due to that solution being based on MSFs, the ideas discussed in this paper are directly applicable to simulations with multiple clocks.…”

Section: Temporal Propertiesmentioning

confidence: 99%

Runtime verification and validation of functional reactive systems

Perez¹,

Nilsson²

2020

J. Funct. Prog.

Self Cite

View full text Add to dashboard Cite

Many types of interactive applications, including reactive systems implemented in hardware, interactive physics simulations and games, raise particular challenges when it comes to testing and debugging. Reasons include de facto lack of reproducibility and difficulties of automatically generating suitable test data. This paper demonstrates that certain variants of functional reactive programming (FRP) implemented in pure functional languages can mitigate such difficulties by offering referential transparency at the level of whole programs. This opens up for a multi-pronged approach for assisting with testing and debugging that works across platforms, including assertions based on temporal logic, recording and replaying of runs (also from deployed code), and automated random testing using QuickCheck. When combined with extensible forms of FRP that allow for constrained side effects, it allows us to not only validate software simulations but to analyse the effect of faults in reactive systems, confirm the efficacy of fault tolerance mechanisms and perform software- and hardware-in-the-loop testing. The approach has been validated on non-trivial systems implemented in several existing FRP implementations, by means of careful debugging using a tool that allows the test or simulation under scrutiny to be controlled, moving along the execution time line, and pin-pointing of violations of assertions on personal computers as well as external devices.

show abstract

Rhine: FRP with type-level clocks

Cited by 16 publications

References 19 publications

Asynchronous Modal FRP

Asynchronous Modal FRP

Hailstorm: A Statically-Typed, Purely Functional Language for IoT Applications

Runtime verification and validation of functional reactive systems

Contact Info

Product

Resources

About