Provide an option to convert a method with IAsyncEnumerable to IList, ReadOnlySpan, Span along side or instead of IEnumerable

[virzak]

IEnumerable implementation is not necessarily the fastest and Span does not implement it

[virzak]

Some extra details:

We need to be able to replace different parameters in different ways.

One way to do that is to introduce a new attribute to be applied to a parameter only:

[ReplaceWith(Variations = ReadOnlySpan | Span)] this IAsyncEnumerable<T> items

Consider providing these variations for the return type also.

Suggest converting IndexOfMaxSoFarAsync to Span as the first step.

sync-method-generator/tests/GenerationSandbox.Tests/AsyncExtensions.GenericMath.cs

Lines 21 to 57 in c44fe5e

	public static async IAsyncEnumerable<int> IndexOfMaxSoFarAsync<T>(this IAsyncEnumerable<T> items, IProgress<int>? progress = null, [EnumeratorCancellation] CancellationToken ct = default)
	#if NET7_0_OR_GREATER
	where T : IComparisonOperators<T, T, bool>
	#else
	where T : IComparisonOperators<T, T>
	#endif
	{
	#if NET6_0_OR_GREATER
	ArgumentNullException.ThrowIfNull(items);
	#else
	if (source is null)
	{
	throw new ArgumentNullException(nameof(items));
	}
	#endif
	var i = 0;
	T? largestSoFar = default;
	await foreach (var item in items)
	{
	ct.ThrowIfCancellationRequested();
	if ((i & 0x3ff) == 0)
	{
	progress?.Report(i);
	}
	if (largestSoFar is null || largestSoFar < item)
	{
	largestSoFar = item;
	yield return i;
	}
	++i;
	}
	}

The result should be something along these lines:

-public static global::System.Collections.Generic.IEnumerable<int> IndexOfMaxSoFar<T>([] this global::System.Collections.Generic.IEnumerable<T> items)
+    // [ReplaceWith] attribute will need to be removed from all parameters
+public static global::System.Span<int> IndexOfMaxSoFar2<T>(this global::System.Span<T> items)
 #if NET7_0_OR_GREATER
-    where T : global::System.Numerics.IComparisonOperators<T, T, bool>
+where T : global::System.Numerics.IComparisonOperators<T, T, bool>
 #else
     where T : IComparisonOperators<T, T>
 #endif
 {
 #if NET6_0_OR_GREATER
-    global::System.ArgumentNullException.ThrowIfNull(items);
+    // Cannot have null checks on span because you can't box it.
+    // https://learn.microsoft.com/en-us/dotnet/api/system.span-1?view=net-7.0&viewFallbackFrom=dotnet-aspire-8.0#remarks
+    //global::System.ArgumentNullException.ThrowIfNull(items);
 #else
     if (source is null)
     {
         throw new ArgumentNullException(nameof(items));
     }
 #endif

     var i = 0;

     T? largestSoFar = default;

+    // You cannot use yield with foreach Span, so you have to replace it with a List<T>
+    // Figure out the type of the elements `await foreach` yields. This should also be the type parameter of the original IAsyncEnumerable
+    var generated_24t4g4wg3 = new List<int>();
+
+    // Also consider switching to a for loop, which might be faster.
     foreach (var item in items)
     {

         if (largestSoFar is null || largestSoFar < item)
         {
             largestSoFar = item;
-            yield return i;
+            generated_24t4g4wg3.Add(i);
         }

         ++i;
     }
+
+    // Add a return statement to the block
+
+    // if return type is IList, return the generated list, otherwise appropriate span
+
+    // Create array from a list (extra memory)
+    return new Span<int>(generated_24t4g4wg3.ToArray());
+    ////return new CollectionsMarshal.AsSpan(generated_24t4g4wg3);
 }

A future improvement would be to switch from foreach to for statement, but lots of things would need to be considered:

• What are perf improvements?
• Is there an existing indexer and if so what should be done with it?
  • Leave as it and add your own
  • Replace it with a for statement indexer, if it isn't used outside of the loop
  • Use it for for statement condition, if it is only incremented once, by one, at the end of the block