Decompose "TagFirstLast" implementation for speed (#643)

Author: Orace

MoreLinq.Test/TagFirstLastTest.cs

@@ -25,10 +25,10 @@ public class TagFirstLastTest
         [Test]
         public void TagFirstLastDoesOneLookAhead()
         {
-            var source = MoreEnumerable.From(() => 123, () => 456, BreakingFunc.Of<int>());
-            source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast })
-                  .Take(1)
-                  .Consume();
+            using var source = MoreEnumerable.From(() => 123, () => 456, BreakingFunc.Of<int>()).AsTestingSequence();
+            var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast });
+
+            result.Take(1).Consume();
         }
 
         [Test]
@@ -40,34 +40,38 @@ public void TagFirstLastIsLazy()
         [Test]
         public void TagFirstLastWithSourceSequenceOfZero()
         {
-            var source = Enumerable.Empty<int>();
-            var sut = source.TagFirstLast(BreakingFunc.Of<int, bool, bool, int>());
-            Assert.That(sut, Is.Empty);
+            using var source = Enumerable.Empty<int>().AsTestingSequence();
+            var result = source.TagFirstLast(BreakingFunc.Of<int, bool, bool, int>());
+
+            Assert.That(result, Is.Empty);
         }
 
         [Test]
         public void TagFirstLastWithSourceSequenceOfOne()
         {
-            var source = new[] { 123 };
-            source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast })
-                  .AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = true });
+            using var source = new[] { 123 }.AsTestingSequence();
+            var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast });
+
+            result.AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = true });
         }
 
         [Test]
         public void TagFirstLastWithSourceSequenceOfTwo()
         {
-            var source = new[] { 123, 456 };
-            source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast })
-                  .AssertSequenceEqual(new { Item = 123, IsFirst = true,  IsLast = false },
+            using var source = new[] { 123, 456 }.AsTestingSequence();
+            var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast });
+
+            result.AssertSequenceEqual(new { Item = 123, IsFirst = true,  IsLast = false },
                                        new { Item = 456, IsFirst = false, IsLast = true });
         }
 
         [Test]
         public void TagFirstLastWithSourceSequenceOfThree()
         {
-            var source = new[] { 123, 456, 789 };
-            source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast })
-                  .AssertSequenceEqual(new { Item = 123, IsFirst = true,  IsLast = false },
+            using var source = new[] { 123, 456, 789 }.AsTestingSequence();
+            var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast });
+
+            result.AssertSequenceEqual(new { Item = 123, IsFirst = true,  IsLast = false },
                                        new { Item = 456, IsFirst = false, IsLast = false },
                                        new { Item = 789, IsFirst = false, IsLast = true  });
         }

MoreLinq/TagFirstLast.cs

@@ -59,8 +59,24 @@ public static IEnumerable<TResult> TagFirstLast<TSource, TResult>(this IEnumerab
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
 
-            return source.Index() // count-up
-                         .CountDown(1, (e, cd) => resultSelector(e.Value, e.Key == 0, cd == 0));
+            return _(); IEnumerable<TResult> _()
+            {
+                using var enumerator = source.GetEnumerator();
+
+                if (!enumerator.MoveNext())
+                    yield break;
+
+                var current = enumerator.Current;
+                var hasNext = enumerator.MoveNext();
+                yield return resultSelector(current, true, !hasNext);
+
+                while (hasNext)
+                {
+                    current = enumerator.Current;
+                    hasNext = enumerator.MoveNext();
+                    yield return resultSelector(current, false, !hasNext);
+                }
+            }
         }
     }
 }