Interleave irregular enumerables with circular strategy

[GoogleCodeExporter]

result: !a1!b2!c3!a4!b5!c1!a2!b3!c4!a5!b1!c2!a3!b4!c5!a1... (Hope I got that 
right, you get the idea). The length of the IEnumerables is unknown of course 
and the result should be lazy-evaluated.

There may already be a way to do this but I didn't see anything obvious like 
this:

public static IEnumerable<T> Interleave<T>(params IEnumerable<T>[] 
sequencesToInterleave)
{
 ... 
}

foreach (var item in Interleave(new string[] { "!" }, new string[] { "a", "b", 
"c" }, new string[] { "1", "2", "3", "4", "5" }))
{
                    Console.Write(item.ToString());
}

Original issue reported on code.google.com by virtan...@gmail.com on 9 May 2014 at 12:18

[GoogleCodeExporter]

Here's my first attempt at this. It produces the result atleast.

            public IEnumerable<T> Interleave<T>(params IEnumerable<T>[] sequencesToInterleave)
            {
                var ls = sequencesToInterleave;
                var lsl = ls.Length;
                List<IEnumerator<T>> ies = new List<IEnumerator<T>>(lsl);
                for (int i = 0; i < lsl; i++)
                {
                    var en = ls[i].GetEnumerator();
                    ies.Add(en);
                    //en.MoveNext();
                }
                while (true)
                {
                    for (int i = 0; i < lsl; i++)
                    {
                        var e=ies[i];
                        if (!e.MoveNext()) { e.Reset(); if (!e.MoveNext()) continue; }
                        yield return e.Current;
                    }
                }
            }

Original comment by virtan...@gmail.com on 9 May 2014 at 1:06

[GoogleCodeExporter]

This variation should stop the yielding once the longest enumerable reaches its 
end... Not sure I'm happy with how it returns 6 of the non-numeric chars for 
the test above while the longest enum has 5 numeric chars. I don't know how to 
fix this yet.

        public static IEnumerable<T> InterleaveForLongest<T>(params IEnumerable<T>[] sequencesToInterleave)
        {
            var ls = sequencesToInterleave;
            var lsl = ls.Length;
            bool[] resets = new bool[lsl];
            List<IEnumerator<T>> ies = new List<IEnumerator<T>>(lsl);
            for (int i = 0; i < lsl; i++) ies.Add(ls[i].GetEnumerator());
            while (true)
            {
                for (int i = 0; i < lsl; i++)
                {
                    var e = ies[i];
                    if (!e.MoveNext()) {
                        e.Reset(); resets[i] = true;
                        if (resets.All(x => x == true)) yield break;
                        if (!e.MoveNext()) continue;
                    }
                    yield return e.Current;
                }
            }
        }

Original comment by virtan...@gmail.com on 9 May 2014 at 1:23

[GoogleCodeExporter]

Here's the final code I ended up with for now. I needed to group some data by 
custom key and then interleave the values of each group...

var g = data.GroupBy(x => x.type);
foreach (var item in InterleaveForLongestG(g)) 
Console.WriteLine(item.ToString());

        public static IEnumerable<T> InterleaveForLongestG<K, T>(IEnumerable<IGrouping<K, T>> sequencesToInterleave)
        {
            var ls = sequencesToInterleave.ToList();
            var lsl = ls.Count;
            bool[] resets = new bool[lsl];
            List<IEnumerator<T>> ies = new List<IEnumerator<T>>(lsl);
            for (int i = 0; i < lsl; i++) ies.Add(ls[i].ToList().GetEnumerator());
            while (true)
            {
                for (int i = 0; i < lsl; i++)
                {
                    var e = ies[i];
                    if (!e.MoveNext())
                    {
                        e.Reset(); resets[i] = true;
                        if (resets.All(x => x == true)) yield break;
                        if (!e.MoveNext()) continue;
                    }
                    yield return e.Current;
                }
            }
        }

Original comment by virtan...@gmail.com on 9 May 2014 at 1:58

[GoogleCodeExporter]

Turns out I also needed a predicate for more control. Here's hopefully the 
final things I ended up using.

        public static IEnumerable<T> EnumInfiniteInterleaved<T>(Func<T, bool> predicate, params IEnumerable<T>[] sequencesContractoInterleave)
        {
            var ls = sequencesContractoInterleave;
            var lsl = ls.Length;
            if (lsl < 2) throw new ArgumentOutOfRangeException("Atleast two sequences required");
            List<IEnumerator<T>> ies = new List<IEnumerator<T>>(lsl);
            for (int i = 0; i < lsl; i++) ies.Add(ls[i].GetEnumerator());
            while (true)
            {
                for (int i = 0; i < lsl; i++)
                {
                    var e = ies[i];
                nxt:
                    if (!e.MoveNext()) { e.Reset(); if (!e.MoveNext()) continue; }
                    if (!predicate(e.Current)) goto nxt;
                    yield return e.Current;
                }
            }
        }
        public static IEnumerable<T> EnumInfinite<T>(Func<T, bool> predicate, IEnumerable<T> source)
        {
            if (source == null) yield break; // be a gentleman
            IEnumerator<T> e = source.GetEnumerator();

        iterateAllAndBackToStart:
            while (e.MoveNext())
            {
                var c = e.Current;
                if (predicate(e.Current)) yield return c;
            }
            e.Reset();
            goto iterateAllAndBackToStart;
        }

Original comment by virtan...@gmail.com on 9 May 2014 at 1:40

[GoogleCodeExporter]

This issue has been migrated to:
https://github.com/MoreLINQ/morelinq/issues/89
The conversation continues there.
DO NOT post any further comments to the issue tracker on Google Code as it is 
shutting down.
You can also just subscribe to the issue on GitHub to receive notifications of 
any further development.

Original comment by azizatif on 21 Aug 2015 at 6:56