Unintuitive behavior (to me) in Reactive.jl - julia

Question

My question relates to the Reactive package https://github.com/JuliaLang/Reactive.jl
I have read the tutorial and am experimenting, learning about the reactive programming approach. I try the following code and it works as expected:
using Reactive
x = Signal(100)
z = map(v -> v + 500, x; typ=Int64, init=500)
dar = rand(90:110,10)
for i in dar
push!(x, i)
println(value(z))
end
This leads, as expected, to 10 random numbers betwwen 590 and 610 being printed:
500
591
609
609
605
593
602
596
590
594
So far, so good. Now, suppose I want to collect the outputs of signal z after each update, say in a vector c:
using Reactive
x = Signal(100)
z = map(v -> v + 500, x; typ=Int64, init=500)
dar = rand(90:110,10)
c = Vector()
for i in dar
push!(x, i)
push!(c, value(z))
end
However, instead of Vector c having ten random numbers between 590 and 610, c is a Vector containing the value 500 ten times:
10-element Array{Any,1}:
500
500
500
500
500
500
500
500
500
500
I am trying to understand if this behavior is caused by something I don't understand about Reactive programming; maybe combining for loops and Signals is a no-no? I would appreciate any insight into what is causing this behavior.
For reference, I am using Julia 0.4.5 inside an IJulia notebook.

Answer 1

Julia's Reactive.jl library is designed to allow Reactive programming in Julia. The crux is that only signal are reactive, and they are either independent or dependent on other signals. In the example, x is an independent signal, and the default update to the signal will call push!. z is dependent signal on x, which is why it gets automatically updated when x changes.
Now, these are the only two signals, notice that c is defined to be Vector(), which is not a signal but a normal array in Julia. So any code that runs on it only performs once like all non-reactive languages. Therefore
for i in dar
push!(x, i)
push!(c, value(z))
end
will only allocate to c once, when the code is first run, whereby z still holds its default value of 500 due to init=500 in the code. This make intuitive sense. In fact, if c is changed due to z, then we have made the underlying behaviour of Julia to be reactive, and this is volatile and so is undesirable...
So how do we make c update whenever z does? The correct way is to use Reactive programming all the way, and so c should be a dependent signal of z. Since c maintains the state of z, the correct construct in Reactive programming is foldp, which stands for "fold over past values".
A code that works is the following:-
using Reactive
x = Signal(100)
z = map(v -> v + 500, x)
c = foldp((acc, value) -> push!(acc, value), Int[], z)
for i in rand(90:110, 10)
push!(x, i)
yield() #Can also use Reactive.run_till_now()
println(value(z))
end
#show value(c)
You will get c to be the array of all previous values of z (except the initial value by choice, so if you want the initial value too that can be easily done). Notice that Reactive programming retains a similar code complexity, but adds in the reactive capability. This make the code more elegant and easier to maintain.
Using yield() or Reactive.run_till_now() is as recommended in the comment, so I shall skim on the explanation. But my opinion is that if you need to do that, then you are likely not using reactive programming correctly, or your problem will fit other paradigm better.
This is how I would write:-
using Reactive
x = Signal(100)
z = map(x) do v
result = v + 500
println(result)
return result
end
c = foldp(Int[], z) do acc, value
push!(acc, value)
end
for i in rand(90:110, 10)
push!(x, i)
end
#show value(c)
Notice that the reactive part is self describing. Now z prints itself whenever it is updated, which is descriptive instead of imperative. So even though update is async, we will still capture an update to z. The imperative code of pushing to x is by itself, keeping things modular. The code is high level enough and easy to read, without low level routine passing functions like yield() inside such a high level script.