feat: Add SelectMany and SelectManyAsync extension methods

- Add SelectMany for IAsyncEnumerable to flatten IEnumerable and IAsyncEnumerable results
- Add SelectManyAsync for IAsyncEnumerable to flatten async projections
- Add SelectManyAsync for IEnumerable to support async flattening operations
- Include array-specific overloads for automatic type inference
- Add comprehensive unit tests for all SelectMany variations
- Add example demonstrating usage patterns

The array overloads enable type inference to work automatically when returning arrays from async lambdas,
eliminating the need for explicit type parameters in common scenarios.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: thomhurst

EnumerableAsyncProcessor.Example/SelectManyExample.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+
+namespace EnumerableAsyncProcessor.Example;
+
+public static class SelectManyExample
+{
+    private static async IAsyncEnumerable<int> GenerateAsyncEnumerable(int count, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        for (int i = 1; i <= count; i++)
+        {
+            await Task.Yield();
+            yield return i;
+        }
+    }
+
+    public static async Task RunExample()
+    {
+        Console.WriteLine("SelectMany Extension Examples");
+        Console.WriteLine("=============================\n");
+        
+        // Example 1: SelectMany on IAsyncEnumerable with IEnumerable
+        Console.WriteLine("Example 1: IAsyncEnumerable.SelectMany with IEnumerable:");
+        var asyncEnum = GenerateAsyncEnumerable(3);
+        var results1 = new List<int>();
+        await foreach (var item in asyncEnum.SelectMany(x => Enumerable.Range(x * 10, 2)))
+        {
+            results1.Add(item);
+        }
+        Console.WriteLine($"Input: [1, 2, 3] -> Output: [{string.Join(", ", results1)}]");
+        
+        // Example 2: SelectManyAsync on IAsyncEnumerable with Task<IEnumerable>
+        Console.WriteLine("\nExample 2: IAsyncEnumerable.SelectManyAsync with Task<IEnumerable>:");
+        var asyncEnum2 = GenerateAsyncEnumerable(3);
+        var results2 = new List<int>();
+        await foreach (var item in asyncEnum2.SelectManyAsync(async x =>
+        {
+            await Task.Delay(10);
+            return new[] { x * 100, x * 100 + 1 };
+        }))
+        {
+            results2.Add(item);
+        }
+        Console.WriteLine($"Input: [1, 2, 3] -> Output: [{string.Join(", ", results2)}]");
+        
+        // Example 3: SelectManyAsync on IEnumerable with IAsyncEnumerable
+        Console.WriteLine("\nExample 3: IEnumerable.SelectManyAsync with IAsyncEnumerable:");
+        var enumerable = Enumerable.Range(1, 3);
+        var results3 = new List<int>();
+        await foreach (var item in enumerable.SelectManyAsync(x => GenerateAsyncEnumerable(2)))
+        {
+            results3.Add(item);
+        }
+        Console.WriteLine($"Input: [1, 2, 3] -> Output: [{string.Join(", ", results3)}]");
+        
+        // Example 4: Flattening nested collections
+        Console.WriteLine("\nExample 4: Flattening nested async collections:");
+        var categories = new[] { "A", "B" };
+        var results4 = new List<string>();
+        await foreach (var item in categories.SelectManyAsync(async cat =>
+        {
+            await Task.Delay(10); // Simulate async work
+            return Enumerable.Range(1, 3).Select(n => $"{cat}{n}").ToArray();
+        }))
+        {
+            results4.Add(item);
+        }
+        Console.WriteLine($"Categories: [A, B] -> Flattened: [{string.Join(", ", results4)}]");
+    }
+}

EnumerableAsyncProcessor.UnitTests/SelectManyExtensionsTests.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using EnumerableAsyncProcessor.Extensions;
+using TUnit.Assertions;
+using TUnit.Core;
+
+namespace EnumerableAsyncProcessor.UnitTests;
+
+public class SelectManyExtensionsTests
+{
+    private static async IAsyncEnumerable<int> GenerateAsyncEnumerable(int count, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        for (int i = 1; i <= count; i++)
+        {
+            await Task.Yield();
+            cancellationToken.ThrowIfCancellationRequested();
+            yield return i;
+        }
+    }
+
+    private static async IAsyncEnumerable<int> GenerateAsyncRange(int start, int count, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        for (int i = start; i < start + count; i++)
+        {
+            await Task.Yield();
+            cancellationToken.ThrowIfCancellationRequested();
+            yield return i;
+        }
+    }
+
+    [Test]
+    public async Task SelectMany_IAsyncEnumerable_WithIEnumerable_FlattensResults()
+    {
+        var asyncEnumerable = GenerateAsyncEnumerable(3);
+        
+        var results = new List<int>();
+        await foreach (var item in asyncEnumerable.SelectMany(x => Enumerable.Range(x * 10, 3)))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2, 3]
+        // Output: [10,11,12, 20,21,22, 30,31,32]
+        await Assert.That(results).IsEquivalentTo(new[] { 10, 11, 12, 20, 21, 22, 30, 31, 32 });
+    }
+
+    [Test]
+    public async Task SelectMany_IAsyncEnumerable_WithIAsyncEnumerable_FlattensResults()
+    {
+        var asyncEnumerable = GenerateAsyncEnumerable(3);
+        
+        var results = new List<int>();
+        await foreach (var item in asyncEnumerable.SelectMany(x => GenerateAsyncRange(x * 10, 2)))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2, 3]
+        // Output: [10,11, 20,21, 30,31]
+        await Assert.That(results).IsEquivalentTo(new[] { 10, 11, 20, 21, 30, 31 });
+    }
+
+    [Test]
+    public async Task SelectManyAsync_IAsyncEnumerable_WithTaskIEnumerable_FlattensResults()
+    {
+        var asyncEnumerable = GenerateAsyncEnumerable(3);
+        
+        var results = new List<string>();
+        await foreach (var item in asyncEnumerable.SelectManyAsync(async x =>
+        {
+            await Task.Delay(10);
+            return Enumerable.Range(x * 10, 2).Select(n => n.ToString());
+        }))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2, 3]
+        // Output: ["10","11", "20","21", "30","31"]
+        await Assert.That(results).IsEquivalentTo(new[] { "10", "11", "20", "21", "30", "31" });
+    }
+
+    [Test]
+    public async Task SelectManyAsync_IAsyncEnumerable_WithTaskIAsyncEnumerable_FlattensResults()
+    {
+        var asyncEnumerable = GenerateAsyncEnumerable(2);
+        
+        var results = new List<int>();
+        await foreach (var item in asyncEnumerable.SelectManyAsync(async x =>
+        {
+            await Task.Delay(10);
+            return GenerateAsyncRange(x * 100, 3);
+        }))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2]
+        // Output: [100,101,102, 200,201,202]
+        await Assert.That(results).IsEquivalentTo(new[] { 100, 101, 102, 200, 201, 202 });
+    }
+
+    [Test]
+    public async Task SelectManyAsync_IEnumerable_WithIAsyncEnumerable_FlattensResults()
+    {
+        var enumerable = Enumerable.Range(1, 3);
+        
+        var results = new List<int>();
+        await foreach (var item in enumerable.SelectManyAsync(x => GenerateAsyncRange(x * 10, 2)))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2, 3]
+        // Output: [10,11, 20,21, 30,31]
+        await Assert.That(results).IsEquivalentTo(new[] { 10, 11, 20, 21, 30, 31 });
+    }
+
+    [Test]
+    public async Task SelectManyAsync_IEnumerable_WithTaskIEnumerable_FlattensResults()
+    {
+        var enumerable = Enumerable.Range(1, 3);
+        
+        var results = new List<string>();
+        await foreach (var item in enumerable.SelectManyAsync(async x =>
+        {
+            await Task.Delay(10);
+            return new[] { $"A{x}", $"B{x}" };
+        }))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2, 3]
+        // Output: ["A1","B1", "A2","B2", "A3","B3"]
+        await Assert.That(results).IsEquivalentTo(new[] { "A1", "B1", "A2", "B2", "A3", "B3" });
+    }
+
+    [Test]
+    public async Task SelectManyAsync_IEnumerable_WithTaskIAsyncEnumerable_FlattensResults()
+    {
+        var enumerable = Enumerable.Range(1, 2);
+        
+        var results = new List<int>();
+        await foreach (var item in enumerable.SelectManyAsync(async x =>
+        {
+            await Task.Delay(10);
+            return GenerateAsyncRange(x * 100, 3);
+        }))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2]
+        // Output: [100,101,102, 200,201,202]
+        await Assert.That(results).IsEquivalentTo(new[] { 100, 101, 102, 200, 201, 202 });
+    }
+
+    [Test]
+    public async Task SelectMany_WithEmptySubCollections_HandlesCorrectly()
+    {
+        var asyncEnumerable = GenerateAsyncEnumerable(3);
+        
+        var results = new List<int>();
+        await foreach (var item in asyncEnumerable.SelectMany(x => 
+            x == 2 ? Enumerable.Empty<int>() : new[] { x * 10 }))
+        {
+            results.Add(item);
+        }
+        
+        // Input: [1, 2, 3]
+        // Output: [10, 30] (2 produces empty)
+        await Assert.That(results).IsEquivalentTo(new[] { 10, 30 });
+    }
+
+    [Test]
+    public async Task SelectMany_WithCancellation_ThrowsOperationCanceledException()
+    {
+        using var cts = new CancellationTokenSource();
+        var asyncEnumerable = GenerateAsyncEnumerable(100);
+        
+        cts.CancelAfter(50);
+        
+        var results = new List<int>();
+        await Assert.ThrowsAsync<OperationCanceledException>(async () =>
+        {
+            await foreach (var item in asyncEnumerable.SelectMany(
+                x => Enumerable.Range(x * 10, 10), cts.Token))
+            {
+                results.Add(item);
+                await Task.Delay(10);
+            }
+        });
+    }
+
+    [Test]
+    public async Task SelectManyAsync_HandlesExceptions()
+    {
+        var asyncEnumerable = GenerateAsyncEnumerable(3);
+        
+        var results = asyncEnumerable.SelectManyAsync(async x =>
+        {
+            if (x == 2)
+            {
+                throw new InvalidOperationException("Test exception");
+            }
+            await Task.Delay(10);
+            return new[] { x * 10 };
+        });
+        
+        var items = new List<int>();
+        await Assert.ThrowsAsync<InvalidOperationException>(async () =>
+        {
+            await foreach (var item in results)
+            {
+                items.Add(item);
+            }
+        });
+        
+        // Should have processed first item before exception
+        await Assert.That(items).IsEquivalentTo(new[] { 10 });
+    }
+
+    [Test]
+    public async Task SelectMany_ComplexNesting_WorksCorrectly()
+    {
+        // Test a more complex scenario with nested SelectMany using LINQ's built-in
+        var data = new[] { 1, 2 };
+        
+        var results = System.Linq.Enumerable.SelectMany(data, x => 
+            System.Linq.Enumerable.SelectMany(Enumerable.Range(1, 2), y => 
+                new[] { $"{x}-{y}-A", $"{x}-{y}-B" })).ToList();
+        
+        await Assert.That(results).IsEquivalentTo(new[] 
+        { 
+            "1-1-A", "1-1-B", "1-2-A", "1-2-B",
+            "2-1-A", "2-1-B", "2-2-A", "2-2-B"
+        });
+    }
+}