Discrete reactive programming in Fusion

[dphfox]

So far, Fusion has almost entirely based itself on principles of continuous-time functional reactive programming. That is to say, all primitives are modelled as containers for values which have a value at all times. There is no notion of 'emitting an event' per se - that's merely an implementation detail of Fusion. This even extends to Observer objects, perhaps the most discrete-like primitive; they're still fundamentally about watching a continuous-time value for changes, and merely translating that into an imperative effect.

However, Fusion's reactive graph is not built solely to support these kinds of continuous-time values; in fact, it can already naturally support discrete reactive programming too. Graph objects and state objects are not the same thing; objects on the reactive graph need not implement any state management at all.

Historically, some others have noted that Fusion could be perfectly modelled with discrete reactive libraries such as Rx, and ask why Fusion itself does not extend its definitions of reactive primitives into the discrete domain. While we can indeed model continuous-time FRP using discrete primitives (in fact, that's what we do under the hood), the question in my mind is more about the difference in mental model between the two, On an anecdotal level, I've always been attracted to the simple mathematical roots of continuous-time models, because this representation most naturally allows me to omit the effects of time-based events on the outcome of a system. I'm personally most partial to this design of library, because it entirely eliminates timing-based bugs such as race conditions without adding mental overhead to the users of the library. While discrete functional reactive programming does help with a lot of the problems imperative programming faces, and certainly still leads to a better DX, I do not feel that it can make guarantees quite as strong.

Of course, continuous-time models are not always the best choice. There are a few select edge cases where discrete reactive programming can provide a simpler or more elegant solution to a problem, for example: where the intersection between imperative and reactive systems requires the programmer to think about events happening over time in order to properly translate between the two mediums.

The question then is whether Fusion should implement any primitives that enable the user to program in a more discrete FRP style. This is something that I'm intensely deliberating upon, because in my mind anything that can reasonably be modelled as a continuous-time system is best modelled as such for the previously-mentioned reasons, and the presence of discrete primitives may confuse and obscure those solutions. We have the technology ready-to-go if we ever choose to do this, and I don't plan to change anything about how graph objects work for the foreseeable future. It's merely a question of: "Will this lead to more footguns than necessary?"