Unexpected behavior of Rx.Observable.reduce takeUntil concat - system.reactive

Question

I am surprised about the behavior of the following code (see https://plnkr.co/edit/OVc26DmXpvXqSOJsQAoh?p=preview):
let empty = Observable.empty();
let source = Observable.range(1, 5)
.map(i =>
Observable.timer(i * 2000, 1000).map(x => "source " + i + ": " + x).take(10))
.reduce((s1, s2) => s1.takeUntil(s2).concat(s2), empty)
.mergeAll();
var subscription = source.subscribe(
function (x) {
console.log('Next: ' + x);
},
function (err) {
console.log('Error: ' + err);
},
function () {
console.log('Completed');
});
yields
Next: source 1: 0
Next: source 1: 1
--- a long pause here ---
Next: source 5: 0
Next: source 5: 1
Next: source 5: 2
Next: source 5: 3
Next: source 5: 4
Next: source 5: 5
Next: source 5: 6
Next: source 5: 7
Next: source 5: 8
Next: source 5: 9
Completed
but I had hoped to see all sequences show up inbetween. What went wrong?
Edit:
Note that using share()not always cures it. This code fails:
let originalSequence = Observable.timer(0, 1000).take(10).share();
let empty = Observable.empty();
let source = Observable.range(1, 5)
.map(i =>
originalSequence.delay(i * 2000).map(x => "source " + i + ": " + x))
.reduce((s1, s2) => s1.takeUntil(s2).concat(s2), empty)
.mergeAll();
and this code works as I expect and I do not understand why
let empty = Observable.empty();
let source = Observable.range(1, 5)
.map(i =>
Observable.timer(i * 2000, 1000).map(x => "source " + i + ": " + x).take(10).share())
.reduce((s1, s2) => s1.takeUntil(s2).concat(s2), empty)
.mergeAll();
Edit 2:
The C# version also has a behavior I would not expect, but at the same time behaves differently:
using System;
using System.Linq;
using System.Reactive.Linq;
using System.Threading;
namespace RxScanProblem
{
class Program
{
static void Main(string[] args)
{
var originalSequence = Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)).Take(10).Select(i => (long)i).Publish();
var empty = Observable.Empty<string>();
var source = Observable.Range(1, 5)
.Select(i => originalSequence.Delay(TimeSpan.FromSeconds(2 * i)).Select(x => "source " + i + ": " + x))
.Aggregate(empty, (s1, s2) => s1.TakeUntil(s2).Concat(s2))
.SelectMany(x => x);
source.Subscribe(
s => Console.WriteLine("Next: " + s),
ex => Console.WriteLine("Error: " + ex.Message),
() => Console.WriteLine("Completed"));
originalSequence.Connect();
// Dirty, I know
Thread.Sleep(20000);
}
}
}
yields (with some delay)
Next: source 1: 0
Next: source 1: 1
Next: source 1: 2
Edit 3
Also switch() does not behave as i would expect!
let empty = Observable.empty();
let source = Observable.range(1, 5)
.map(i => Observable.timer(i * 2000, 1000).map(x => "source " + i + ": " + x).take(10))
.switch();
yields
Next: source 5: 0
Next: source 5: 1
Next: source 5: 2
Next: source 5: 3
Next: source 5: 4
Next: source 5: 5
Next: source 5: 6
Next: source 5: 7
Next: source 5: 8
Next: source 5: 9
Same (!) behavior for C#
var originalSequence = Observable.Timer(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)).Take(10).Select(i => (long)i).Publish();
var empty = Observable.Empty<string>();
var source = Observable.Range(1, 5)
.Select(i => originalSequence.Delay(TimeSpan.FromSeconds(2 * i)).Select(x => "source " + i + ": " + x))
.Switch();

Answer 1

Lets look at what your code does.
let source = Observable.range(1, 5)
.map(i =>
Observable.timer(i * 2000, 1000).map(x => "source " + i + ": " + x).take(10))
.reduce((s1, s2) => s1.takeUntil(s2).concat(s2), empty)
.mergeAll();
First map will transform {1,2,3,4,5} into
s1 = Observable.timer(1 * 2000, 1000).map(x => "source 1: " + x).take(10));
s2 = Observable.timer(2 * 2000, 1000).map(x => "source 2: " + x).take(10));
s3 = Observable.timer(3 * 2000, 1000).map(x => "source 3: " + x).take(10));
s4 = Observable.timer(4 * 2000, 1000).map(x => "source 4: " + x).take(10));
s5 = Observable.timer(5 * 2000, 1000).map(x => "source 5: " + x).take(10));
next, reduce will glue them together like this:
s1.takeUntil(s2).concat(s2)
.takeUntil(s3).concat(s3)
.takeUntil(s4).concat(s4)
.takeUntil(s5).concat(s5)
now lets write a small marble to show what all these streams will yield:
s1 --0123456789
s2 ----0123456789
s3 ------0123456789
s4 --------0123456789
s5 ----------0123456789
s1.takeUntil(s2) --01|
.concat(s2) --01----0123456789
takeUntil(s3) --01--|
.concat(s3) --01--------0123456789
takeUntil(s4) --01----|
.concat(s4) --01------------0123456789
takeUntil(s5) --01------|
.concat(s5) --01----------------0123456789
Now, if you use share(), you effectively publish the source. Publish means you multicast to all subscribers at the same time. This works well if there are 2 subscribers, even if one arrives later than the other, the source will continue mid-stream for the second subscriber. Things change when the first subscriber disconnect before the second one arrive. To preserve resources, share() will disconnect the source, and resubscribe to it later. Given you started with cold observables, this means they will start again at the beginning, with the long wait.
Since you use .takeUntil(s2).concat(s2), you will actually unsubscribe from s2 right before you subscribe to s2 again. After all concat wont connect until it receives completed from takeUntil and takeUntil wont emit completed until s2 has yielded. If s2 yields, takeUntil will instantly unsubscribe from it before forwarding completed down stream. This means that s2 will have no subscribers for a split second, and the source will be reset.
What you probably expected was that s2 would stay connected the entire time, and would keep running in the background. This would work if you had used a hot observable resulting from an active source instead of a cold observable made hot trough share().
I will not go into detail on switch() since i believe you already understood the problem there: It will disconnect the previous source when the next one arrives, not when the next one yields.
What you can do, is write your own 'switchOnYield'
source.publish(src => src
.flatMap(inner1 =>
inner1.takeUntil(src.flatMap(inner2 => inner2.take(1)))
))
What this does is merge all sources from source together, but add takeUntil on them with all latter sources. If any of the later sources yields, the first bunch will be unsubscribed. This works because the first time src yields, .flatMap(inner1 will run. The second time it yields, src.flatMap(inner2 will merge any item from the later source into the takeUntil operator.
demo here

Answer 2

I would strongly suggest you post expected or desired output. It's not clear what you want. For the C# sample, changing source to the following gets you closer (I think, again, I'm not sure):
var source = Observable.Range(1, 5)
.Select(i => originalSequence
.Delay(TimeSpan.FromSeconds(2 * i))
.Select(x => "source " + i + ": " + x)
)
//making sure s2 is shared properly, thus concated properly
.Aggregate(empty, (s1, s2) => s2.Publish( _s2 => s1
.TakeUntil(_s2)
.Concat(_s2)
))
.SelectMany(x => x);
That yields the following output:
Next: source 1: 0
Next: source 1: 1
Next: source 2: 1
Next: source 3: 1
Next: source 4: 1
Next: source 5: 1
Next: source 5: 2
Next: source 5: 3
Next: source 5: 4
Next: source 5: 5
Next: source 5: 6
Next: source 5: 7
Next: source 5: 8
Next: source 5: 9
Completed
This makes sense to me. If you can post desired output, I'll help you get there.