test: fixing test

src/Codibre.EnumerableExtensions.Branching/AsyncBranchingBuilder.cs

@@ -7,5 +7,20 @@
 namespace Codibre.EnumerableExtensions.Branching;
 public class AsyncBranchingBuilder<T>(IAsyncEnumerable<T> source) : BaseBranchingBuilder<T>
 {
-    protected override IAsyncEnumerable<T> Source { get; } = source;
+    internal override async ValueTask<(LinkedNode<T>?, Task)> Iterate()
+    {
+        var enumerator = source.GetAsyncEnumerator();
+        var node = await enumerator.MoveNextAsync() ? new LinkedNode<T>(enumerator.Current) : null;
+        return (node, node is null ? Task.CompletedTask : Task.Run(async () =>
+        {
+            try
+            {
+                while (await enumerator.MoveNextAsync()) node = node.Next = new LinkedNode<T>(enumerator.Current);
+            }
+            finally
+            {
+                node.End = true;
+            }
+        }));
+    }
 }

src/Codibre.EnumerableExtensions.Branching/BaseBranchingBuilder.cs

@@ -16,30 +16,15 @@ internal BaseBranchingBuilder<T> Add(Func<IAsyncEnumerable<T>, Task> branch)
         return this;
     }
 
-    protected abstract IAsyncEnumerable<T> Source { get; }
-
     public async Task Run()
     {
-        var enumerator = Source.GetAsyncEnumerator();
-        ILinkedNode<T>? node = await enumerator.MoveNextAsync() ? new LinkedNode<T>(enumerator.Current) : null;
-        var iterate = Iterate(node, enumerator);
+        var (node, iterate) = await Iterate();
         await Task.WhenAll(
             _branches
                 .Select((x, index) => x(node.GetBranchedIterable()))
                 .Append(iterate)
         );
     }
 
-    private static async Task Iterate(ILinkedNode<T>? node, IAsyncEnumerator<T> enumerator)
-    {
-        if (node is null) return;
-        try
-        {
-            while (await enumerator.MoveNextAsync()) node = node.Next = new LinkedNode<T>(enumerator.Current);
-        }
-        finally
-        {
-            node.End = true;
-        }
-    }
+    internal abstract ValueTask<(LinkedNode<T>?, Task)> Iterate();
 }

src/Codibre.EnumerableExtensions.Branching/BranchingBuilder.cs

@@ -8,5 +8,20 @@ namespace Codibre.EnumerableExtensions.Branching;
 
 public class BranchingBuilder<T>(IEnumerable<T> source) : BaseBranchingBuilder<T>
 {
-    protected override IAsyncEnumerable<T> Source { get; } = source.ToAsyncEnumerable();
+    internal override ValueTask<(LinkedNode<T>?, Task)> Iterate()
+    {
+        var enumerator = source.GetEnumerator();
+        var node = enumerator.MoveNext() ? new LinkedNode<T>(enumerator.Current) : null;
+        return ValueTask.FromResult((node, node is null ? Task.CompletedTask : Task.Run(async () =>
+        {
+            try
+            {
+                while (enumerator.MoveNext()) node = node.Next = new LinkedNode<T>(enumerator.Current);
+            }
+            finally
+            {
+                node.End = true;
+            }
+        })));
+    }
 }

src/Codibre.EnumerableExtensions.Branching/Internal/BranchedEnumerable.cs

@@ -2,7 +2,7 @@
 
 namespace Codibre.EnumerableExtensions.Branching.Internal;
 
-internal record BranchedEnumerable<T>(ILinkedNode<T> node) : IAsyncEnumerable<T>
+internal record BranchedEnumerable<T>(LinkedNode<T> node) : IAsyncEnumerable<T>
 {
     public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
         => new BranchedEnumerator<T>(node);

src/Codibre.EnumerableExtensions.Branching/Internal/BranchedEnumerator.cs

@@ -4,11 +4,18 @@ namespace Codibre.EnumerableExtensions.Branching.Internal;
 
 internal record BranchedEnumerator<T> : IAsyncEnumerator<T>
 {
-    private ILinkedNode<T> _node;
-    public BranchedEnumerator(ILinkedNode<T> node) => _node = new LinkedNode<T>(default)
+    private LinkedNode<T> _node;
+    private readonly int _altenateOn;
+    private int _count;
+    public BranchedEnumerator(LinkedNode<T> node, int altenateOn = 100)
     {
-        Next = node,
-    };
+        _node = new LinkedNode<T>(default)
+        {
+            Next = node,
+        };
+        _altenateOn = altenateOn;
+        _count = altenateOn;
+    }
 
     public T Current => _node.Value;
     public ValueTask DisposeAsync() => ValueTask.CompletedTask;
@@ -18,6 +25,12 @@ public async ValueTask<bool> MoveNextAsync()
         while (!_node.End && _node.Next is null) await Task.Yield();
         if (_node.Next is null) return false;
         _node = _node.Next;
+        _count--;
+        if (_count <= 0)
+        {
+            _count = _altenateOn;
+            await Task.Yield();
+        }
         return true;
     }
 }

src/Codibre.EnumerableExtensions.Branching/Internal/BranchingHelper.cs

@@ -8,6 +8,6 @@ namespace Codibre.EnumerableExtensions.Branching.Internal;
 
 internal static class BranchingHelper
 {
-    internal static IAsyncEnumerable<T> GetBranchedIterable<T>(this ILinkedNode<T>? node)
-        => node is null ? new List<T>().ToAsyncEnumerable() : new BranchedEnumerable<T>(node);
+    internal static IAsyncEnumerable<T> GetBranchedIterable<T>(this LinkedNode<T>? node)
+        => node is null ? Array.Empty<T>().ToAsyncEnumerable() : new BranchedEnumerable<T>(node);
 }

src/Codibre.EnumerableExtensions.Branching/Internal/LinkedNode.cs

@@ -1,8 +1,8 @@
 namespace Codibre.EnumerableExtensions.Branching.Internal;
 
-internal struct LinkedNode<T>(T value) : ILinkedNode<T>
+internal record LinkedNode<T>(T value)
 {
     public T Value { get; } = value;
-    public ILinkedNode<T>? Next { get; set; } = null;
+    public LinkedNode<T>? Next { get; set; } = null;
     public bool End { get; set; } = false;
 }

test/Codibre.EnumerableExtensions.Branching.Benchmark/Benchmarks.cs

@@ -13,7 +13,7 @@ public static IEnumerable<int> AddOps(this IEnumerable<int> source, int value)
 
 public class Benchmarks
 {
-    [Params(100, 1000, 10000)]
+    [Params(100)]
     public int _size = 100;
     private IEnumerable<int> GetBaseEnumerable()
         => Enumerable.Range(0, _size)

test/Codibre.EnumerableExtensions.Branching.Test/AsyncEnumerableExtensionsTest.cs

@@ -74,7 +74,7 @@ await enumerable.Branch()
     public async Task Should_Intercalate_The_Steps_Between_Every_Branch()
     {
         // Arrange
-        var total = 100;
+        var total = 10000;
         var list = Enumerable.Range(0, total).ToAsyncEnumerable();
         List<int> steps = [];
         var enumerable = Op(list);
@@ -99,7 +99,6 @@ await enumerable.Branch()
             .Run();
 
         // Assert
-        helper.WriteLine(string.Join(",", steps.GetRange(0, 8)));
         var refValue = steps[0];
         steps.TakeWhile((x) => x == refValue).Count().Should().BeLessThan(total);
     }

test/Codibre.EnumerableExtensions.Branching.Test/EnumerableExtensionsTest.cs

@@ -74,7 +74,7 @@ await enumerable.Branch()
     public async Task Should_Intercalate_The_Steps_Between_Every_Branch()
     {
         // Arrange
-        var total = 100;
+        var total = 10000;
         var list = Enumerable.Range(0, total);
         List<int> steps = [];
         var enumerable = Op(list);
@@ -99,7 +99,6 @@ await enumerable.Branch()
             .Run();
 
         // Assert
-        helper.WriteLine(string.Join(",", steps.GetRange(0, 8)));
         var refValue = steps[0];
         steps.TakeWhile((x) => x == refValue).Count().Should().BeLessThan(total);
     }