Breaking changes to Computed object update timings

[dphfox]

Right now, some users of Fusion treat Computed objects as observers, placing non-computation code inside of them.

print("Creating the Value")
local value = scope:Value(2)
print("Creating the Computed")
scope:Computed(function(use)
    print("-> The computed has been invoked!")
    print("-> The computed sees", use(value))
end)
print("Updating the Value")
value:set(5)

This produces the expected output.

Creating the Value
Creating the Computed
-> The computed has been invoked!
-> The computed sees 2
Updating the Value
-> The computed sees 5

However, there are two possible changes on the horizon that will break this use case.

Dissolving state objects

As per #301, Computed objects that do not use() any state objects may be changed to return a constant value rather than a state object. This involves running the computation before the Computed is constructed, with a special use() function that only returns constants, and errors for state.

This means it's possible (and expected) that a Computed object might only partially execute, causing a duplicate print in our example:

Creating the Value
Creating the Computed
-> The computed has been invoked!
-> The computed has been invoked!
-> The computed sees 2
Updating the Value
-> The computed sees 5

This isn't certain to go through yet - it'll need a bit more testing to definitively say whether it's something we want to go ahead with or not - but if it does go through, then it may cause less predictable behaviour if you depend on non-computational code in Computed objects.

Execution model changes

Fusion is moving to a hybrid push-pull execution model, which means that (aside from the above test for constant-ness) computations won't run until you ask for their result.

Creating the Value
Creating the Computed
-> The computed has been invoked!
Updating the Value

To better demonstrate this, here's an idiomatic example.

print("Creating the Value")
local value = scope:Value(2)
print("Creating the Computed")
local double = scope:Computed(function(use)
    print("-> double has been invoked!")
    return use(value) * 2
end)
print("Updating the Value")
value:set(5)
print("Printing out values")
print("value:", peek(value), "double:", peek(double))

Creating the Value
Creating the Computed
-> double has been invoked!
Updating the Value
Printing out values
-> double has been invoked!
value: 5 double: 10

This change is designed to not only reduce the amount of computation work done unnecessarily, but also to improve correctness - it helps us guarantee that objects you access are updated in the right order.

The solution

These changes are the reason why we have always advised - and continue to advise - the use of Observer objects instead of Computed objects whenever you care about the execution of the code, rather than only its result.

Even with the above two changes being applied, you will notice this observer example remains functional.

print("Creating the Value")
local value = scope:Value(2)
print("Creating the Observer")
scope:Observer(value):onBind(function()
    print("-> The observer has been invoked!")
    print("-> The observer sees", peek(value))
end)
print("Updating the Value")
value:set(5)

This produces the desired output again.

Creating the Value
Creating the Observer
-> The observer has been invoked!
-> The observer sees 2
Updating the Value
-> The observer sees 5

There are efforts to improve observers right now, over in #258 and #310, so that it is easier to use them in place of Computed objects.

See you there :)

• Dan