Extended Usage of the .. Operator

[naratteu]

The .. operator is currently used in the following ways:

byte[] end = [8,8,8];
byte[] bin = [1,2,3,4,5, ..end]; // spread element
Console.WriteLine(string.Join(',',bin));
if (bin is [.., 8,8,8]) // slice pattern
  Console.WriteLine(string.Join(',',bin[..^end.Length])); // range
/*
    Output:
    1,2,3,4,5,8,8,8
    1,2,3,4,5
*/

I believe the .. operator could be extended to support additional use cases. For example:

byte[] end = [8,8,8];
IEnumerable<byte> Bin()
{
    for (byte i = 1; i <= 5; i++)
        yield return i;
-   foreach (var b in end) yield return b;
+   yield return ..end; // yield spread
}
Console.WriteLine(string.Join(',',Bin()));
/*
    Output:
    1,2,3,4,5,8,8,8
*/

public class ExampleJsInterop(IJSRuntime jsRuntime) : IAsyncDisposable
{
    private readonly Lazy<Task<IJSObjectReference>> moduleTask = new(() => jsRuntime.InvokeAsync<IJSObjectReference>(
            "import", "./_content/lib/exampleJsInterop.js").AsTask());
    //...
    public async ValueTask DisposeAsync()
    {
        if (moduleTask.IsValueCreated)
        {
-           var module = await moduleTask.Value;
-           await module.DisposeAsync();
+           await moduleTask.Value..DisposeAsync(); // async access
        }
    }
}

record Record(int Id, string Name);
async Task<string?> GetName(Func<Task<Record>>? func = null)
{
    Task<Record>? task = func?.Invoke();
-   if (task is not null)
-   {
-       Record rec = await task;
-       return rec.Name;
-   }
-   else
-   {
-       return null;
-   }
+   return await task?..Name; // null-conditional async access
}

This idea is purely from the perspective of a user, so I’m not sure how complex it would be to implement this feature or what issues might arise if it were implemented. I would appreciate your feedback. Thank you!

[naratteu]

It might also be nice to combine the collection expression itself with yield.

-   foreach (var b in end) yield return b;
+   yield return [..end];

-   yield return 1;
-   yield return 2;
-   yield return 3;
-   foreach (var b in end) yield return b;
+   yield return [1,2,3,..end];

[HaloFour]

// yield spread

#378

The syntax isn't the problem, it's the implicit quadratic nature of such an operation.