concatMap / flatMap should run immediately, on the same scheduler - reactive-programming

Question

Given a Service object, I want to be sure that each function call to the service will not result in side effects. In my case whatever function A is doing, nothing will be executed in function B unless the scheduler is available.
Here's what this looks like:
class Service {
func handleJobA(input: String) -> Observable<String> {
return Observable.just(input)
.do(onNext: { (str) in
print ("Job A: \(str)")
})
.concatMap { input -> Observable<String> in
return Observable.just("Job AA: \(input)")
.delay(2, scheduler: self.scheduler)
.do(onNext: { (str) in
print (str)
})
}
.subscribeOn(scheduler)
}
func handleJobB(input: String) -> Observable<String> {
return Observable.just(input)
.do(onNext: { (str) in
print ("Job B: \(str)")
})
.delay(1, scheduler: scheduler)
.concatMap { input -> Observable<String> in
return Observable.just("Job BB: \(input)")
.do(onNext: { (str) in
print (str)
})
}
.subscribeOn(scheduler)
}
let scheduler = SerialDispatchQueueScheduler(internalSerialQueueName: "Service")
}
let service = Service()
_ = Observable.from(["1","2","3"])
.concatMap { service.handleJobA(input: $0) }
.subscribe(onNext:{
print($0 + " √")
})
_ = Observable.from(["1","2","3"])
.concatMap { service.handleJobB(input: $0) }
.subscribe(onNext:{
print($0 + " √")
})
import PlaygroundSupport
PlaygroundPage.current.needsIndefiniteExecution = true
At the moment, the output is:
Job A: 1
Job B: 1
Job BB: 1
Job BB: 1 √
Job B: 2
Job AA: 1
Job AA: 1 √
Job A: 2
Job BB: 2
Job BB: 2 √
Job B: 3
Job BB: 3
Job BB: 3 √
Job AA: 2
Job AA: 2 √
Job A: 3
Job AA: 3
Job AA: 3 √
However, this shows the fundamental problem. The internal delays (which can happen from anything, really.. network, processing) cause the observable processing to get out of "order".
What I want is this:
Job A: 1
Job AA: 1
Job AA: 1 √
Job B: 1
Job BB: 1
Job BB: 1 √
Job B: 2
Job BB: 2
Job BB: 2 √
Job B: 3
Job BB: 3
Job BB: 3 √
Job A: 2
Job AA: 2
Job AA: 2 √
Job A: 3
Job AA: 3
Job AA: 3 √
That means, once a function has started processing a task, no one else get's access unless it is done.
I received a very good answer previously. It's not totally applicable, as flatMap/concatMap (?) both seem to dislike the schedulers.
My theory is that the concatMap call indeed does the right job, but then schedules the child sequence omissions to the end of the schedulers queue, whereas I would want it at the front, to be processed next.

Answer 1

I can't explain schedulers behaviour... But I can make a small proposal
...once a function has started processing a task, no one else get's
access unless it is done...
You can pass all your handleJob calls through concatMap to get the behaviour you require:
Observable
.from([1,2,3,4,5,6])
.flatMap({ (value) -> Observable<String> in
switch value % 2 == 0 {
case true:
return service.handleJobA(input: "\(value)")
case false:
return service.handleJobB(input: "\(value)")
}
})
.subscribe(onNext:{
print($0 + " √")
})
Service class example:
private class Service {
private lazy var result = PublishSubject<(index: Int, result: String)>()
private lazy var publish = PublishSubject<(index: Int, input: String, transformation: (String) -> String)>()
private lazy var index: Int = 0
private lazy var disposeBag = DisposeBag()
init() {
publish
.asObservable()
.concatMap({ (index, input, transformation) -> Observable<(index: Int, result: String)> in
let dueTime = RxTimeInterval(arc4random_uniform(3) + 1)
return Observable
.just((index: index, result: transformation(input)))
.delay(dueTime, scheduler: self.scheduler)
})
.bind(to: result)
.disposed(by: disposeBag)
}
func handleJobA(input: String) -> Observable<String> {
let transformation: (String) -> String = { string in
return "Job A: \(string)"
}
return handleJob(input: input, transformation: transformation)
}
func handleJobB(input: String) -> Observable<String> {
let transformation: (String) -> String = { string in
return "Job B: \(string)"
}
return handleJob(input: input, transformation: transformation)
}
func handleJob(input: String, transformation: #escaping (String) -> String) -> Observable<String> {
index += 1
defer {
publish.onNext((index, input, transformation))
}
return result
.filter({ [expected = index] (index, result) -> Bool in
return expected == index
})
.map({ $0.result })
.take(1)
.shareReplayLatestWhileConnected()
}
let scheduler = SerialDispatchQueueScheduler(internalSerialQueueName: "Service")
}