Low Level Functional Reactive Programming

在低级语言（如C）中，我们严重依赖于内存的抽象-值被放置在一个连续的内存单元阵列中，可以引用并视为任何类型的数据。虽然这使我们能够利用一些工具来提高程序的效率，并轻松地与某些硬件进行交互，但这是一个很难找到错误的来源，这些错误会大大降低此类程序的可靠性。这项工作通常福尔斯两类：为C添加安全性（例如通过链接器），以及为更安全的语言添加C的功能。为了实现后者，你需要特定的编程语言结构，而这些结构通常在我们常见的高级语言中找不到。完全为此目的而设计的语言，如Cyclone和Rust，已经成功地将与内存交互所需的结构与安全功能（如基于区域的内存管理和所有权）结合起来。由于其自然可验证的性质，这种范式最近已经得到了改进，但由于范式的差异，很难与低级别程序进行交互。这里的主要问题是，与低级程序的交互是依赖于时间的--你必须在执行的某个部分访问一个内存单元，以便获得你想要的值--在函数式范式中，这依赖于编写本质上是命令式的代码，这就引出了我们的方法。这种时间依赖性可以通过将我们的存储单元视为值流来避免，也就是说，随着时间的推移，值的序列而不是在执行期间访问的单个值。考虑到这一点，我们可以获取我们的内存单元流，对它们执行一系列计算，并将它们写在某个地方。只要我们有流，我们就可以依次访问所有的值，所以排序就不那么成问题了。关于函数式反应式编程（FRP），一种设计用于处理这些流的函数式编程子范式，有相当多的工作。这种模式允许我们采取流，如上面的和联合收割机，以构建一个完整的信号graph.By结合现有的工作FRP和有限的工作，在函数式编程中使用低级别的数据，我们提出了一个优雅的替代功能语言和低级别的数据之间的接口。这旨在允许以前需要低级语言（如机器人）的反应式应用程序更安全地用高级语言编写。这也可以在其他上下文中使用，例如以声明方式声明着色器。

In low level languages such as C, we rely heavily on the abstraction of memory - values are placed in a contiguous array of memory cells that can be referenced to and treated as data of any type. While this allows us to utilise a number of tools to improve program efficiency and easily interact with some hardware, it is a source of difficult to find bugs that can greatly reduce the reliability of such programs.Much research has been done to mitigate these bugs. This work usually falls into one of two categories: adding safety to C (such as via linters), and adding C's features to safer languages. In order to do the latter, you need specific programming language constructs not normally found in our common high level languages. Languages entirely designed for this purpose, like Cyclone and Rust, have seen success in combining the constructs needed for interacting with memory with safety features such as region-based memory management and ownership.Little has been done however to integrate this work with pure functional programming. This paradigm has seen improved uptake recently due to its naturally verifiable nature, but has difficulty interacting with low level programs due to the difference in paradigm. The main problem here is the fact that interacting with low level programs is time dependent - you have to access a memory cell during a certain part of execution in order to be given the value that you want - which in a functional paradigm relies on writing essentially imperative code.This brings us to our approach. This time dependency can be avoided by considering our memory cell as a stream of values, that is, a sequence of values over time rather than single values accessed during execution. With this in mind, we can take our memory cell streams, perform a series of computations on them and write those out somewhere. As long as we have the stream, we have access to all the values in turn so sequencing is less of an issue.There is a sizeable body of work about Functional Reactive Programming (FRP), a functional programming subparadigm designed to work with these streams. This paradigm allows us to take streams such as the ones above and combine them in order to construct a full signal graph.By combining the existing work on FRP and the limited work on low level data use in functional programming, we propose an elegant alternative to current interfaces between functional languages and low level data. This aims to allow reactive applications that would previously require low level languages (such as in robotics) to be written in higher level languages more safely. This could also be used in other contexts, such as declaratively declaring shaders.