How to implement the logic without state variables

user_674548 0
Viewed 43

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?

rx-swift reactive-programming
1 Answers

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])
    }
}
user_5064410
Related