Unexpected behavior of cyclic signals

[mode89]

If a cyclic signal goes out of scope, other nodes (that are implemented in terms of the cyclic signal) don't behave as expected.

Here is an example that works as expected:

let sink = Sink::new();
let stream = sink.stream();

let mut start = Stream::never();
let mut stop = Stream::never();

let in_process = Signal::cyclic(|in_process| {
    start = in_process
        .snapshot(&stream, |in_process, _|
            if in_process { None } else { Some(()) })
        .filter_some();
    stop = in_process
        .snapshot(&stream, |in_process, _|
            if in_process { Some(()) } else { None })
        .filter_some();
    start.map(|_| true)
        .merge(&stop.map(|_| false))
        .hold(false)
});

let mut events = start.map(|_| 0).merge(&stop.map(|_| 1)).events();

sink.send(());
assert_eq!(events.next(), Some(0));
sink.send(());
assert_eq!(events.next(), Some(1));
sink.send(());
assert_eq!(events.next(), Some(0));

But if we limit lifetime of the cyclic signal, the test breaks on the second assertion:

let sink = Sink::new();
let stream = sink.stream();

let mut start = Stream::never();
let mut stop = Stream::never();

{
    let in_process = Signal::cyclic(|in_process| {
        start = in_process
            .snapshot(&stream, |in_process, _|
                if in_process { None } else { Some(()) })
            .filter_some();
        stop = in_process
            .snapshot(&stream, |in_process, _|
                if in_process { Some(()) } else { None })
            .filter_some();
        start.map(|_| true)
            .merge(&stop.map(|_| false))
            .hold(false)
    });
}

let mut events = start.map(|_| 0).merge(&stop.map(|_| 1)).events();

sink.send(());
assert_eq!(events.next(), Some(0));
sink.send(());
assert_eq!(events.next(), Some(1));
sink.send(());
assert_eq!(events.next(), Some(0));

By the way, great library - ergonomics are really nice :)

[mode89]

After giving a look to the source code, it seems that start and stop depend on SignalCycle::signal version of in_process. And SignalCycle::signal doesn't track value returned by Signal::cyclic (which is also the value returned by the function passed into Signal::cyclic) as it's dependency, so when that value dropped, SignalCycle::signal (as well as start and stop) doesn't get any updates.

Please correct me if I'm wrong.

[milibopp]

It has been a while since I touched this code, so I definitely need some time to get back into it. Anyway, a fix with a regression test case and PR would be appreciated.