How to implement the logic without state variables - reactive-programming

Question

There are two observables: the first named activator emits booleans. The second named signaler emits void events. There's a function f() which must be called under the next conditions:
If the last event from activator is true, and event from signaler comes, call f(). Otherwise (the last activator's event is false, or activator has not yet emitted anything), "remember" that signaler sent the event. As soon as activator emits true, call f() and clear "remembered" flag.
Example:
let activator = PublishRelay<Bool>()
let signaler = PublishRelay<Void>()
signaler.accept(()) // activator not emitted yet, just remember that signal came
activator.accept(true) // go to active state. signal is waiting. call f()
signaler.accept(()) // already activated. call f()
activator.accept(false)// go to inactive state
activator.accept(true) // go to active state.
signaler.accept(()) // call f()
activator.accept(false)// go to inactive state
signaler.accept(()) // inactive state, remember that signal came
signaler.accept(()) // still inactive state, remember that signal came
activator.accept(true) // go to active state. there is signal waiting. call f().
signaler.accept(()) // active state. call f().
I can achieve the desired behaviour using two state variables _isActive and _waiting:
var _isActive = false
var _waiting = false
activator.bind { isActive in
self._isActive = isActive
if isActive && self._waiting {
f()
self._waiting = false
}
}.disposed(by: _bag)
signaler.bind {
if self._isActive {
f()
} else {
self._waiting = true
}
}.disposed(by: _bag)
The question is: can I implement it without state variables, only by means of reactive operators?

Answer 1

You need a state machine, but you can contain the state so you aren't leaving the monad... Something like this:
func example(activator: Observable<Bool>, signaler: Observable<Void>) -> Observable<Void> {
enum Action {
case signal
case active(Bool)
}
return Observable.merge(signaler.map(to: Action.signal), activator.map(Action.active))
.scan((isWaiting: false, isActive: false, fire: Void?.none)) { state, action in
switch action {
case .signal:
if state.isActive {
return (state.isWaiting, state.isActive, ())
}
else {
return (true, state.isActive, .none)
}
case .active(let active):
if active && state.isWaiting {
return (false, active, ())
}
else {
return (state.isWaiting, active, .none)
}
}
}
.compactMap { $0.fire }
}
Note how the logic inside the scan closure is the same as the external logic you already have. With the above, you can now do something like this:
let activator = PublishRelay<Bool>()
let signaler = PublishRelay<Void>()
example(
activator: activator.asObservable(),
signaler: signaler.asObservable()
)
.bind(onNext: f)
Lastly, as a bonus. Here's a unit test proving it works:
class RxSandboxTests: XCTestCase {
func test() {
let scheduler = TestScheduler(initialClock: 0)
let activator = scheduler.createColdObservable([.next(20, true), .next(40, false), .next(50, true), .next(70, false), .next(100, true)])
let signaler = scheduler.createColdObservable([.next(10, ()), .next(30, ()), .next(60, ()), .next(80, ()), .next(90, ()), .next(110, ())])
let result = scheduler.start {
example(activator: activator.asObservable(), signaler: signaler.asObservable())
}
XCTAssertEqual(result.events.map { $0.time }, [220, 230, 260, 300, 310])
}
}