Interleave eagerly calls MoveNext

[Orace]

From this part of the code:

MoreLINQ/MoreLinq/Interleave.cs

Lines 135 to 139 in 13c8c83

	// yield the values of each iterator's current position
	for (var index = 0; index < iterCount; index++)
	{
	yield return iteratorList[index].Current;
	}

We can see that interleave eagerly have called MoveNext on all the enumerators from all the input sequence before yielding the first value.

This is useless for the ImbalancedInterleaveStrategy.Skip strategy. And this strategy is the only one accessible from the user (the strategies enum is not public).

[atifaziz]

I don't think that's the case. It removes any iterator whose MoveNext returns false and updates the counters like iterCount accordingly:

MoreLINQ/MoreLinq/Interleave.cs

Lines 122 to 127 in 13c8c83

	case ImbalancedInterleaveStrategy.Skip:
	iteratorList.RemoveAt(index); // no longer visit this particular iterator
	--iterCount; // reduce the expected number of iterators to visit
	--index; // decrement iterator index to compensate for index shifting
	--consumedIterators; // decrement consumer iterator count to stay in balance
	break;

The loop that yields then uses the updated list of iterators and count.

Your test in PR #696 is flawed.

[Orace]

I don't think that's the case. It removes any iterator whose MoveNext returns false and updates the counters like iterCount accordingly

@atifaziz, as usual I was not clear enough in my first attempt to explain what is wrong here.

The subject of this issue is not about the possible multiple calls to MoveNext after a sequence end.
It's about useless call to MoveNext.

Considering this code.

var resultSequence = sequenceA.Interleave(sequenceB);

Expected behavior
One call to MoveNext on an enumerator of resultSequence should result on one call to MoveNext on one enumerator of the input sequence.

var resultSequence = sequenceA.Interleave(sequenceB);
var e = resultSequence.GetEnumerator();
e.MoveNext(); // call to MoveNext on the enumerator of sequenceA
e.MoveNext(); // call to MoveNext on the enumerator of sequenceB
e.MoveNext(); // call to MoveNext on the enumerator of sequenceA
...

Current behavior

One call to MoveNext on an enumerator of resultSequence result on calls to MoveNext on both enumerators of both input sequences.

var resultSequence = sequenceA.Interleave(sequenceB);
var e = resultSequence.GetEnumerator();
e.MoveNext(); // call to MoveNext on the enumerator of sequenceA and sequenceB
e.MoveNext();
e.MoveNext(); // call to MoveNext on the enumerator of sequenceA and sequenceB
...

Here the test I originally committed:

MoreLINQ/MoreLinq.Test/InterleaveTest.cs

Lines 38 to 53 in c9aa710

	/// <summary>
	/// Verify that interleaving do not call enumerators MoveNext method eagerly
	/// </summary>
	[Test]
	public void TestInterleaveDoNoCallMoveNextEagerly()
	{
	void Code()
	{
	var sequenceA = Enumerable.Range(1, 1);
	var sequenceB = MoreEnumerable.From<int>(() => throw new TestException());
	sequenceA.Interleave(sequenceB).Take(1).Consume();
	}
	Assert.DoesNotThrow(Code);
	}

Here what is tested:
If you take one element from the result sequence, only sequenceA should be enumerated.

[atifaziz]

Okay that makes more sense. I was focusing too much on the loop you quoted initially but you are right, it should avoid iterating other sequences unless needed. Thanks for the clarification.