Fix Interleave to prevent eager MoveNext calls

MoreLinq.Test/InterleaveTest.cs

@@ -35,6 +35,23 @@ public void TestInterleaveIsLazy()
             new BreakingSequence<int>().Interleave(new BreakingSequence<int>());
         }
 
+        /// <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);
+        }
+
         /// <summary>
         /// Verify that interleaving disposes those enumerators that it managed
         /// to open successfully

MoreLinq/Interleave.cs

@@ -19,8 +19,6 @@ namespace MoreLinq
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics;
-    using System.Linq;
 
     public static partial class MoreEnumerable
     {
@@ -45,125 +43,63 @@ public static partial class MoreEnumerable
         /// <returns>A sequence of interleaved elements from all of the source sequences</returns>
 
         public static IEnumerable<T> Interleave<T>(this IEnumerable<T> sequence, params IEnumerable<T>[] otherSequences)
-        {
-            return Interleave(sequence, ImbalancedInterleaveStrategy.Skip, otherSequences);
-        }
-
-        /// <summary>
-        /// Interleaves the elements of two or more sequences into a single sequence, applying the specified strategy when sequences are of unequal length
-        /// </summary>
-        /// <remarks>
-        /// Interleave combines sequences by visiting each in turn, and returning the first element of each, followed
-        /// by the second, then the third, and so on. So, for example:<br/>
-        /// <code><![CDATA[
-        /// {1,1,1}.Interleave( {2,2,2}, {3,3,3} ) => { 1,2,3,1,2,3,1,2,3 }
-        /// ]]></code>
-        /// This operator behaves in a deferred and streaming manner.<br/>
-        /// When sequences are of unequal length, this method will use the imbalance strategy specified to
-        /// decide how to continue interleaving the remaining sequences. See <see cref="ImbalancedInterleaveStrategy"/>
-        /// for more information.<br/>
-        /// The sequences are interleaved in the order that they appear in the <paramref name="otherSequences"/>
-        /// collection, with <paramref name="sequence"/> as the first sequence.
-        /// </remarks>
-        /// <typeparam name="T">The type of the elements of the source sequences</typeparam>
-        /// <param name="sequence">The first sequence in the interleave group</param>
-        /// <param name="imbalanceStrategy">Defines the behavior of the operator when sequences are of unequal length</param>
-        /// <param name="otherSequences">The other sequences in the interleave group</param>
-        /// <returns>A sequence of interleaved elements from all of the source sequences</returns>
-
-        static IEnumerable<T> Interleave<T>(this IEnumerable<T> sequence, ImbalancedInterleaveStrategy imbalanceStrategy, params IEnumerable<T>[] otherSequences)
         {
             if (sequence == null) throw new ArgumentNullException(nameof(sequence));
             if (otherSequences == null) throw new ArgumentNullException(nameof(otherSequences));
-            if (otherSequences.Any(s => s == null))
-                throw new ArgumentNullException(nameof(otherSequences), "One or more sequences passed to Interleave was null.");
 
-            return _(); IEnumerable<T> _()
-            {
-                var sequences = new[] { sequence }.Concat(otherSequences);
+            return InterleaveSkip(otherSequences.Prepend(sequence));
+        }
 
-                // produce an iterator collection for all IEnumerable<T> instancess passed to us
-                var iterators = sequences.Select(e => e.GetEnumerator()).Acquire();
-                List<IEnumerator<T>> iteratorList = null;
+        private static IEnumerable<T> InterleaveSkip<T>(this IEnumerable<IEnumerable<T>> sequences)
+        {
+            var enumerators = new LinkedList<IEnumerator<T>>();
 
-                try
+            try
+            {
+                // First pass. create enumerators.
+                foreach (var sequence in sequences)
                 {
-                    iteratorList = new List<IEnumerator<T>>(iterators);
-                    iterators = null;
-                    var shouldContinue = true;
-                    var consumedIterators = 0;
-                    var iterCount = iteratorList.Count;
-
-                    while (shouldContinue)
-                    {
-                        // advance every iterator and verify a value exists to be yielded
-                        for (var index = 0; index < iterCount; index++)
-                        {
-                            if (!iteratorList[index].MoveNext())
-                            {
-                                // check if all iterators have been consumed and we can terminate
-                                // or if the imbalance strategy informs us that we MUST terminate
-                                if (++consumedIterators == iterCount || imbalanceStrategy == ImbalancedInterleaveStrategy.Stop)
-                                {
-                                    shouldContinue = false;
-                                    break;
-                                }
+                    if (sequence == null)
+                        throw new ArgumentException("An item is null.", nameof(sequences));
 
-                                iteratorList[index].Dispose(); // dispose the iterator sice we no longer need it
+                    var enumerator = sequence.GetEnumerator();
 
-                                // otherwise, apply the imbalance strategy
-                                switch (imbalanceStrategy)
-                                {
-                                    case ImbalancedInterleaveStrategy.Pad:
-                                        var newIter = iteratorList[index] = Generate(default(T), x => default).GetEnumerator();
-                                        newIter.MoveNext();
-                                        break;
+                    // Immediately dispose enumerators of empty sequences.
+                    if (!enumerator.MoveNext())
+                    {
+                        enumerator.Dispose();
+                        continue;
+                    }
 
-                                    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;
-                                }
+                    yield return enumerator.Current;
+                    enumerators.AddLast(enumerator);
+                }
 
-                            }
-                        }
+                var node = enumerators.First;
+                while (node != null)
+                {
+                    var nextNode = node.Next;
 
-                        if (shouldContinue) // only if all iterators could be advanced
-                        {
-                            // yield the values of each iterator's current position
-                            foreach (var iterator in iteratorList)
-                                yield return iterator.Current;
-                        }
+                    var enumerator = node.Value;
+                    if (enumerator.MoveNext())
+                    {
+                        yield return enumerator.Current;
                     }
-                }
-                finally
-                {
-                    Debug.Assert(iteratorList != null || iterators != null);
-                    foreach (var iter in (iteratorList ?? (IList<IEnumerator<T>>) iterators))
-                        iter.Dispose();
+                    else
+                    {
+                        enumerator.Dispose();
+                        enumerators.Remove(node);
+                    }
+
+                    // Work on next node or restart from first one.
+                    node = nextNode ?? enumerators.First;
                 }
             }
-        }
-
-        /// <summary>
-        /// Defines the strategies available when Interleave is passed sequences of unequal length
-        /// </summary>
-        enum ImbalancedInterleaveStrategy
-        {
-            /// <summary>
-            /// Extends a sequence by padding its tail with default(T)
-            /// </summary>
-            Pad,
-            /// <summary>
-            /// Removes the sequence from the interleave set, and continues interleaving remaining sequences.
-            /// </summary>
-            Skip,
-            /// <summary>
-            /// Stops the interleave operation.
-            /// </summary>
-            Stop,
+            finally
+            {
+                foreach (var enumerator in enumerators)
+                    enumerator.Dispose();
+            }
         }
     }
 }