Update Enumerable.Sequence based on post-merge feedback (#116793)

stephentoub · web-flow · commit 9b4f83ed53c7 · 2025-06-18T16:52:08.000-04:00
* Update Enumerable.Sequence based on post-merge feedback

- Use T.IsPositive/IsZero
- Put zero check first
- Throw for NaN
- Rename a parameter to clarify its purpose
- Add some comments

* Add exception docs
diff --git a/src/libraries/System.Linq.AsyncEnumerable/src/System/Linq/Sequence.cs b/src/libraries/System.Linq.AsyncEnumerable/src/System/Linq/Sequence.cs
@@ -11,15 +11,18 @@ namespace System.Linq
 {
     public static partial class AsyncEnumerable
     {
-        /// <summary>Generates a  sequence that begins with <paramref name="start"/> and yields additional values each incremented by <paramref name="step"/> until <paramref name="endInclusive"/> is reached.</summary>
+        /// <summary>Generates a sequence that begins with <paramref name="start"/> and yields additional values each incremented by <paramref name="step"/> until <paramref name="endInclusive"/> is reached.</summary>
         /// <typeparam name="T">The type of the value to be yielded in the result sequence.</typeparam>
         /// <param name="start">The starting value. This value will always be included in the resulting sequence.</param>
         /// <param name="endInclusive">The ending bound beyond which values will not be included in the sequence.</param>
         /// <param name="step">The amount by which the next value in the sequence should be incremented from the previous value.</param>
         /// <returns>An <see cref="IAsyncEnumerable{T}"/> that contains the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="start"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="step"/> is <see langword="null"/>.</exception>
         /// <exception cref="ArgumentNullException"><paramref name="endInclusive"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="step"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> is NaN.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="endInclusive"/> is NaN.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is NaN.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is greater than zero but <paramref name="endInclusive"/> is less than <paramref name="start"/>.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is less than zero but <paramref name="endInclusive"/> is greater than <paramref name="start"/>.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is zero and <paramref name="endInclusive"/> does not equal <paramref name="start"/>.</exception>
@@ -30,17 +33,43 @@ public static IAsyncEnumerable<T> Sequence<T>(T start, T endInclusive, T step) w
                 ThrowHelper.ThrowArgumentNullException(nameof(start));
             }
 
+            if (T.IsNaN(start))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(start));
+            }
+
             if (endInclusive is null)
             {
                 ThrowHelper.ThrowArgumentNullException(nameof(endInclusive));
             }
 
+            if (T.IsNaN(endInclusive))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(endInclusive));
+            }
+
             if (step is null)
             {
                 ThrowHelper.ThrowArgumentNullException(nameof(step));
             }
 
-            if (step > T.Zero)
+            if (T.IsNaN(step))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(step));
+            }
+
+            if (T.IsZero(step))
+            {
+                // step == 0. If start != endInclusive, then the sequence would be infinite. As such, we validate
+                // that they're equal, and if they are, we return a sequence that yields the start/endInclusive value once.
+                if (start != endInclusive)
+                {
+                    ThrowHelper.ThrowArgumentOutOfRangeException(nameof(step));
+                }
+
+                return Repeat(start, 1);
+            }
+            else if (T.IsPositive(step))
             {
                 // Presumed to be the most common case, step > 0. Validate that endInclusive >= start, as otherwise we can't easily
                 // guarantee that the sequence will terminate.
@@ -52,7 +81,7 @@ public static IAsyncEnumerable<T> Sequence<T>(T start, T endInclusive, T step) w
                 // Otherwise, just produce an incrementing sequence.
                 return IncrementingIterator(start, endInclusive, step);
             }
-            else if (step < T.Zero)
+            else
             {
                 // step < 0. Validate that endInclusive <= start, as otherwise we can't easily guarantee that the sequence will terminate.
                 if (endInclusive > start)
@@ -63,31 +92,20 @@ public static IAsyncEnumerable<T> Sequence<T>(T start, T endInclusive, T step) w
                 // Then produce the decrementing sequence.
                 return DecrementingIterator(start, endInclusive, step);
             }
-            else
-            {
-                // step == 0. If start != endInclusive, then the sequence would be infinite. As such, we validate
-                // that they're equal, and if they are, we return a sequence that yields the start/endInclusive value once.
-                if (start != endInclusive)
-                {
-                    ThrowHelper.ThrowArgumentOutOfRangeException(nameof(step));
-                }
-
-                return Repeat(start, 1);
-            }
 
-            static async IAsyncEnumerable<T> IncrementingIterator(T start, T endInclusive, T step)
+            static async IAsyncEnumerable<T> IncrementingIterator(T current, T endInclusive, T step)
             {
                 Debug.Assert(step > T.Zero);
 
-                yield return start;
+                yield return current;
 
                 while (true)
                 {
-                    T next = start + step;
+                    T next = current + step;
 
-                    if (next >= endInclusive || next <= start)
+                    if (next >= endInclusive || next <= current) // handle overflow and saturation
                     {
-                        if (next == endInclusive && start != next)
+                        if (next == endInclusive && current != next)
                         {
                             yield return next;
                         }
@@ -96,24 +114,24 @@ static async IAsyncEnumerable<T> IncrementingIterator(T start, T endInclusive, T
                     }
 
                     yield return next;
-                    start = next;
+                    current = next;
                 }
             }
 
 
-            static async IAsyncEnumerable<T> DecrementingIterator(T start, T endInclusive, T step)
+            static async IAsyncEnumerable<T> DecrementingIterator(T current, T endInclusive, T step)
             {
                 Debug.Assert(step < T.Zero);
 
-                yield return start;
+                yield return current;
 
                 while (true)
                 {
-                    T next = start + step;
+                    T next = current + step;
 
-                    if (next <= endInclusive || next >= start)
+                    if (next <= endInclusive || next >= current) // handle overflow and saturation
                     {
-                        if (next == endInclusive && start != next)
+                        if (next == endInclusive && current != next)
                         {
                             yield return next;
                         }
@@ -122,7 +140,7 @@ static async IAsyncEnumerable<T> DecrementingIterator(T start, T endInclusive, T
                     }
 
                     yield return next;
-                    start = next;
+                    current = next;
                 }
             }
         }
diff --git a/src/libraries/System.Linq.AsyncEnumerable/tests/SequenceTests.cs b/src/libraries/System.Linq.AsyncEnumerable/tests/SequenceTests.cs
@@ -13,11 +13,15 @@ namespace System.Linq.Tests
     public class SequenceTests : AsyncEnumerableTests
     {
         [Fact]
-        public void NullArguments_Throws()
+        public void InvalidArguments_Throws()
         {
             AssertExtensions.Throws<ArgumentNullException>("start", () => AsyncEnumerable.Sequence((ReferenceAddable)null!, new(1), new(2)));
             AssertExtensions.Throws<ArgumentNullException>("endInclusive", () => AsyncEnumerable.Sequence(new(1), (ReferenceAddable)null!, new(2)));
             AssertExtensions.Throws<ArgumentNullException>("step", () => AsyncEnumerable.Sequence(new(1), new(2), (ReferenceAddable)null!));
+
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("start", () => AsyncEnumerable.Sequence(float.NaN, 1.0f, 1.0f));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("endInclusive", () => AsyncEnumerable.Sequence(1.0f, float.NaN, 1.0f));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("step", () => AsyncEnumerable.Sequence(1.0f, 1.0f, float.NaN));
         }
 
         [Fact]
@@ -251,16 +255,16 @@ private sealed class ReferenceAddable(int value) : INumber<ReferenceAddable>
             public static bool IsImaginaryNumber(ReferenceAddable value) => throw new NotImplementedException();
             public static bool IsInfinity(ReferenceAddable value) => throw new NotImplementedException();
             public static bool IsInteger(ReferenceAddable value) => throw new NotImplementedException();
-            public static bool IsNaN(ReferenceAddable value) => throw new NotImplementedException();
-            public static bool IsNegative(ReferenceAddable value) => throw new NotImplementedException();
+            public static bool IsNaN(ReferenceAddable value) => false;
+            public static bool IsNegative(ReferenceAddable value) => false;
             public static bool IsNegativeInfinity(ReferenceAddable value) => throw new NotImplementedException();
             public static bool IsNormal(ReferenceAddable value) => throw new NotImplementedException();
             public static bool IsOddInteger(ReferenceAddable value) => throw new NotImplementedException();
-            public static bool IsPositive(ReferenceAddable value) => throw new NotImplementedException();
+            public static bool IsPositive(ReferenceAddable value) => false;
             public static bool IsPositiveInfinity(ReferenceAddable value) => throw new NotImplementedException();
             public static bool IsRealNumber(ReferenceAddable value) => throw new NotImplementedException();
             public static bool IsSubnormal(ReferenceAddable value) => throw new NotImplementedException();
-            public static bool IsZero(ReferenceAddable value) => throw new NotImplementedException();
+            public static bool IsZero(ReferenceAddable value) => false;
             public static ReferenceAddable MaxMagnitude(ReferenceAddable x, ReferenceAddable y) => throw new NotImplementedException();
             public static ReferenceAddable MaxMagnitudeNumber(ReferenceAddable x, ReferenceAddable y) => throw new NotImplementedException();
             public static ReferenceAddable MinMagnitude(ReferenceAddable x, ReferenceAddable y) => throw new NotImplementedException();
diff --git a/src/libraries/System.Linq/src/System/Linq/Sequence.cs b/src/libraries/System.Linq/src/System/Linq/Sequence.cs
@@ -11,15 +11,18 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        /// <summary>Generates a  sequence that begins with <paramref name="start"/> and yields additional values each incremented by <paramref name="step"/> until <paramref name="endInclusive"/> is reached.</summary>
+        /// <summary>Generates a sequence that begins with <paramref name="start"/> and yields additional values each incremented by <paramref name="step"/> until <paramref name="endInclusive"/> is reached.</summary>
         /// <typeparam name="T">The type of the value to be yielded in the result sequence.</typeparam>
         /// <param name="start">The starting value. This value will always be included in the resulting sequence.</param>
         /// <param name="endInclusive">The ending bound beyond which values will not be included in the sequence.</param>
         /// <param name="step">The amount by which the next value in the sequence should be incremented from the previous value.</param>
         /// <returns>An <see cref="IEnumerable{T}"/> that contains the sequence.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="start"/> is <see langword="null"/>.</exception>
-        /// <exception cref="ArgumentNullException"><paramref name="step"/> is <see langword="null"/>.</exception>
         /// <exception cref="ArgumentNullException"><paramref name="endInclusive"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="step"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> is NaN.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="endInclusive"/> is NaN.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is NaN.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is greater than zero but <paramref name="endInclusive"/> is less than <paramref name="start"/>.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is less than zero but <paramref name="endInclusive"/> is greater than <paramref name="start"/>.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is zero and <paramref name="endInclusive"/> does not equal <paramref name="start"/>.</exception>
@@ -30,17 +33,43 @@ public static IEnumerable<T> Sequence<T>(T start, T endInclusive, T step) where
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.start);
             }
 
+            if (T.IsNaN(start))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
+            }
+
             if (endInclusive is null)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.endInclusive);
             }
 
+            if (T.IsNaN(endInclusive))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.endInclusive);
+            }
+
             if (step is null)
             {
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.step);
             }
 
-            if (step > T.Zero)
+            if (T.IsNaN(step))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.step);
+            }
+
+            if (T.IsZero(step))
+            {
+                // If start != endInclusive, then the sequence would be infinite. As such, we validate
+                // that they're equal, and if they are, we return a sequence that yields the start/endInclusive value once.
+                if (start != endInclusive)
+                {
+                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.step);
+                }
+
+                return Repeat(start, 1);
+            }
+            else if (T.IsPositive(step))
             {
                 // Presumed to be the most common case, step > 0. Validate that endInclusive >= start, as otherwise we can't easily
                 // guarantee that the sequence will terminate.
@@ -67,7 +96,7 @@ public static IEnumerable<T> Sequence<T>(T start, T endInclusive, T step) where
                 // Otherwise, just produce an incrementing sequence.
                 return IncrementingIterator(start, endInclusive, step);
             }
-            else if (step < T.Zero)
+            else
             {
                 // step < 0. Validate that endInclusive <= start, as otherwise we can't easily guarantee that the sequence will terminate.
                 if (endInclusive > start)
@@ -78,17 +107,6 @@ public static IEnumerable<T> Sequence<T>(T start, T endInclusive, T step) where
                 // Then produce the decrementing sequence.
                 return DecrementingIterator(start, endInclusive, step);
             }
-            else
-            {
-                // step == 0. If start != endInclusive, then the sequence would be infinite. As such, we validate
-                // that they're equal, and if they are, we return a sequence that yields the start/endInclusive value once.
-                if (start != endInclusive)
-                {
-                    ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.step);
-                }
-
-                return Repeat(start, 1);
-            }
 
             static RangeIterator<T>? TryUseRange<TLarger>(T start, T endInclusive, T step, TLarger maxValue) where TLarger : INumber<TLarger>
             {
@@ -101,19 +119,19 @@ public static IEnumerable<T> Sequence<T>(T start, T endInclusive, T step) where
                 return null;
             }
 
-            static IEnumerable<T> IncrementingIterator(T start, T endInclusive, T step)
+            static IEnumerable<T> IncrementingIterator(T current, T endInclusive, T step)
             {
                 Debug.Assert(step > T.Zero);
 
-                yield return start;
+                yield return current;
 
                 while (true)
                 {
-                    T next = start + step;
+                    T next = current + step;
 
-                    if (next >= endInclusive || next <= start)
+                    if (next >= endInclusive || next <= current) // handle overflow and saturation
                     {
-                        if (next == endInclusive && start != next)
+                        if (next == endInclusive && current != next)
                         {
                             yield return next;
                         }
@@ -122,24 +140,24 @@ static IEnumerable<T> IncrementingIterator(T start, T endInclusive, T step)
                     }
 
                     yield return next;
-                    start = next;
+                    current = next;
                 }
             }
 
 
-            static IEnumerable<T> DecrementingIterator(T start, T endInclusive, T step)
+            static IEnumerable<T> DecrementingIterator(T current, T endInclusive, T step)
             {
                 Debug.Assert(step < T.Zero);
 
-                yield return start;
+                yield return current;
 
                 while (true)
                 {
-                    T next = start + step;
+                    T next = current + step;
 
-                    if (next <= endInclusive || next >= start)
+                    if (next <= endInclusive || next >= current) // handle overflow and saturation
                     {
-                        if (next == endInclusive && start != next)
+                        if (next == endInclusive && current != next)
                         {
                             yield return next;
                         }
@@ -148,7 +166,7 @@ static IEnumerable<T> DecrementingIterator(T start, T endInclusive, T step)
                     }
 
                     yield return next;
-                    start = next;
+                    current = next;
                 }
             }
         }
diff --git a/src/libraries/System.Linq/tests/SequenceTests.cs b/src/libraries/System.Linq/tests/SequenceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -11,15 +11,18 @@ namespace System.Linq`
`11`	`11`	`{`
`12`	`12`	`public static partial class AsyncEnumerable`
`13`	`13`	`{`
`14`		`- /// <summary>Generates a sequence that begins with <paramref name="start"/> and yields additional values each incremented by <paramref name="step"/> until <paramref name="endInclusive"/> is reached.</summary>`
	`14`	`+ /// <summary>Generates a sequence that begins with <paramref name="start"/> and yields additional values each incremented by <paramref name="step"/> until <paramref name="endInclusive"/> is reached.</summary>`
`15`	`15`	`/// <typeparam name="T">The type of the value to be yielded in the result sequence.</typeparam>`
`16`	`16`	`/// <param name="start">The starting value. This value will always be included in the resulting sequence.</param>`
`17`	`17`	`/// <param name="endInclusive">The ending bound beyond which values will not be included in the sequence.</param>`
`18`	`18`	`/// <param name="step">The amount by which the next value in the sequence should be incremented from the previous value.</param>`
`19`	`19`	`/// <returns>An <see cref="IAsyncEnumerable{T}"/> that contains the sequence.</returns>`
`20`	`20`	`/// <exception cref="ArgumentNullException"><paramref name="start"/> is <see langword="null"/>.</exception>`
`21`		`- /// <exception cref="ArgumentNullException"><paramref name="step"/> is <see langword="null"/>.</exception>`
`22`	`21`	`/// <exception cref="ArgumentNullException"><paramref name="endInclusive"/> is <see langword="null"/>.</exception>`
	`22`	`+ /// <exception cref="ArgumentNullException"><paramref name="step"/> is <see langword="null"/>.</exception>`
	`23`	`+ /// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> is NaN.</exception>`
	`24`	`+ /// <exception cref="ArgumentOutOfRangeException"><paramref name="endInclusive"/> is NaN.</exception>`
	`25`	`+ /// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is NaN.</exception>`
`23`	`26`	`/// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is greater than zero but <paramref name="endInclusive"/> is less than <paramref name="start"/>.</exception>`
`24`	`27`	`/// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is less than zero but <paramref name="endInclusive"/> is greater than <paramref name="start"/>.</exception>`
`25`	`28`	`/// <exception cref="ArgumentOutOfRangeException"><paramref name="step"/> is zero and <paramref name="endInclusive"/> does not equal <paramref name="start"/>.</exception>`
`@@ -30,17 +33,43 @@ public static IAsyncEnumerable<T> Sequence<T>(T start, T endInclusive, T step) w`
`30`	`33`	`ThrowHelper.ThrowArgumentNullException(nameof(start));`
`31`	`34`	`}`
`32`	`35`
	`36`	`+ if (T.IsNaN(start))`
	`37`	`+ {`
	`38`	`+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(start));`
	`39`	`+ }`
	`40`	`+`
`33`	`41`	`if (endInclusive is null)`
`34`	`42`	`{`
`35`	`43`	`ThrowHelper.ThrowArgumentNullException(nameof(endInclusive));`
`36`	`44`	`}`
`37`	`45`
	`46`	`+ if (T.IsNaN(endInclusive))`
	`47`	`+ {`
	`48`	`+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(endInclusive));`
	`49`	`+ }`
	`50`	`+`
`38`	`51`	`if (step is null)`
`39`	`52`	`{`
`40`	`53`	`ThrowHelper.ThrowArgumentNullException(nameof(step));`
`41`	`54`	`}`
`42`	`55`
`43`		`- if (step > T.Zero)`
	`56`	`+ if (T.IsNaN(step))`
	`57`	`+ {`
	`58`	`+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(step));`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ if (T.IsZero(step))`
	`62`	`+ {`
	`63`	`+ // step == 0. If start != endInclusive, then the sequence would be infinite. As such, we validate`
	`64`	`+ // that they're equal, and if they are, we return a sequence that yields the start/endInclusive value once.`
	`65`	`+ if (start != endInclusive)`
	`66`	`+ {`
	`67`	`+ ThrowHelper.ThrowArgumentOutOfRangeException(nameof(step));`
	`68`	`+ }`
	`69`	`+`
	`70`	`+ return Repeat(start, 1);`
	`71`	`+ }`
	`72`	`+ else if (T.IsPositive(step))`
`44`	`73`	`{`
`45`	`74`	`// Presumed to be the most common case, step > 0. Validate that endInclusive >= start, as otherwise we can't easily`
`46`	`75`	`// guarantee that the sequence will terminate.`
`@@ -52,7 +81,7 @@ public static IAsyncEnumerable<T> Sequence<T>(T start, T endInclusive, T step) w`
`52`	`81`	`// Otherwise, just produce an incrementing sequence.`
`53`	`82`	`return IncrementingIterator(start, endInclusive, step);`
`54`	`83`	`}`
`55`		`- else if (step < T.Zero)`
	`84`	`+ else`
`56`	`85`	`{`
`57`	`86`	`// step < 0. Validate that endInclusive <= start, as otherwise we can't easily guarantee that the sequence will terminate.`
`58`	`87`	`if (endInclusive > start)`
`@@ -63,31 +92,20 @@ public static IAsyncEnumerable<T> Sequence<T>(T start, T endInclusive, T step) w`
`63`	`92`	`// Then produce the decrementing sequence.`
`64`	`93`	`return DecrementingIterator(start, endInclusive, step);`
`65`	`94`	`}`
`66`		`- else`
`67`		`- {`
`68`		`- // step == 0. If start != endInclusive, then the sequence would be infinite. As such, we validate`
`69`		`- // that they're equal, and if they are, we return a sequence that yields the start/endInclusive value once.`
`70`		`- if (start != endInclusive)`
`71`		`- {`
`72`		`- ThrowHelper.ThrowArgumentOutOfRangeException(nameof(step));`
`73`		`- }`
`74`		`-`
`75`		`- return Repeat(start, 1);`
`76`		`- }`
`77`	`95`
`78`		`- static async IAsyncEnumerable<T> IncrementingIterator(T start, T endInclusive, T step)`
	`96`	`+ static async IAsyncEnumerable<T> IncrementingIterator(T current, T endInclusive, T step)`
`79`	`97`	`{`
`80`	`98`	`Debug.Assert(step > T.Zero);`
`81`	`99`
`82`		`- yield return start;`
	`100`	`+ yield return current;`
`83`	`101`
`84`	`102`	`while (true)`
`85`	`103`	`{`
`86`		`- T next = start + step;`
	`104`	`+ T next = current + step;`
`87`	`105`
`88`		`- if (next >= endInclusive \|\| next <= start)`
	`106`	`+ if (next >= endInclusive \|\| next <= current) // handle overflow and saturation`
`89`	`107`	`{`
`90`		`- if (next == endInclusive && start != next)`
	`108`	`+ if (next == endInclusive && current != next)`
`91`	`109`	`{`
`92`	`110`	`yield return next;`
`93`	`111`	`}`
`@@ -96,24 +114,24 @@ static async IAsyncEnumerable<T> IncrementingIterator(T start, T endInclusive, T`
`96`	`114`	`}`
`97`	`115`
`98`	`116`	`yield return next;`
`99`		`- start = next;`
	`117`	`+ current = next;`
`100`	`118`	`}`
`101`	`119`	`}`
`102`	`120`
`103`	`121`
`104`		`- static async IAsyncEnumerable<T> DecrementingIterator(T start, T endInclusive, T step)`
	`122`	`+ static async IAsyncEnumerable<T> DecrementingIterator(T current, T endInclusive, T step)`
`105`	`123`	`{`
`106`	`124`	`Debug.Assert(step < T.Zero);`
`107`	`125`
`108`		`- yield return start;`
	`126`	`+ yield return current;`
`109`	`127`
`110`	`128`	`while (true)`
`111`	`129`	`{`
`112`		`- T next = start + step;`
	`130`	`+ T next = current + step;`
`113`	`131`
`114`		`- if (next <= endInclusive \|\| next >= start)`
	`132`	`+ if (next <= endInclusive \|\| next >= current) // handle overflow and saturation`
`115`	`133`	`{`
`116`		`- if (next == endInclusive && start != next)`
	`134`	`+ if (next == endInclusive && current != next)`
`117`	`135`	`{`
`118`	`136`	`yield return next;`
`119`	`137`	`}`
`@@ -122,7 +140,7 @@ static async IAsyncEnumerable<T> DecrementingIterator(T start, T endInclusive, T`
`122`	`140`	`}`
`123`	`141`
`124`	`142`	`yield return next;`
`125`		`- start = next;`
	`143`	`+ current = next;`
`126`	`144`	`}`
`127`	`145`	`}`
`128`	`146`	`}`