expose Lookup and implement ApplyResultSelector #87

Author: neuecc

src/ZLinq/Linq/ToLookup.cs

@@ -315,8 +315,8 @@ void ResizeAndRehash()
         }
     }
 
-    // .NET ILookup implements ICollection
-    internal sealed class Lookup<TKey, TElement> : ILookup<TKey, TElement>, ICollection<IGrouping<TKey, TElement>>, IReadOnlyCollection<IGrouping<TKey, TElement>>
+    // .NET ILookup implements ICollection and it is public
+    public sealed class Lookup<TKey, TElement> : ILookup<TKey, TElement>, ICollection<IGrouping<TKey, TElement>>, IReadOnlyCollection<IGrouping<TKey, TElement>>
     {
         internal static readonly Lookup<TKey, TElement> Empty = new Lookup<TKey, TElement>();
 
@@ -325,15 +325,15 @@ internal sealed class Lookup<TKey, TElement> : ILookup<TKey, TElement>, ICollect
         readonly int count;
         readonly IEqualityComparer<TKey> comparer;
 
-        public Lookup() // for empty
+        Lookup() // for empty
         {
             this.groups = null;
             this.last = null;
             this.count = 0;
             this.comparer = null!;
         }
 
-        public Lookup(Grouping<TKey, TElement>[]? groupings, Grouping<TKey, TElement>? last, int count, IEqualityComparer<TKey> comparer)
+        internal Lookup(Grouping<TKey, TElement>[]? groupings, Grouping<TKey, TElement>? last, int count, IEqualityComparer<TKey> comparer)
         {
             if (groupings == null)
             {
@@ -368,6 +368,24 @@ public IEnumerable<TElement> this[TKey key]
 
         public int Count => count;
 
+        // Lookup method
+
+        public IEnumerable<TResult> ApplyResultSelector<TResult>(Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
+        {
+            ArgumentNullException.ThrowIfNull(resultSelector);
+
+            if (last is null) yield break;
+            var group = last.NextGroupInAddOrder; // as first.
+            if (group is null) yield break;
+
+            var first = group;
+            do
+            {
+                yield return resultSelector(group.Key, group);
+                group = group.NextGroupInAddOrder;
+            } while (group != null && group != first);
+        }
+
         public bool Contains(TKey key)
         {
             return GetGroup(key) is not null;

tests/ZLinq.Tests/Linq/ToLookupTest.cs

@@ -1,4 +1,6 @@
-namespace ZLinq.Tests.Linq;
+using Shouldly;
+
+namespace ZLinq.Tests.Linq;
 
 public class ToLookupTest
 {
@@ -261,4 +263,51 @@ public void ICollectionCopyToExceptions()
             collection.CopyTo(new IGrouping<int, int>[collection.Count], 1));
     }
 
+    [Fact]
+    public void ApplyResultSelector()
+    {
+        // Arrange
+        var xs = new[] { 1, 2, 3, 4, 5, 1, 2, 3 };
+        var lookup = (ZLinq.Linq.Lookup<int, int>)xs.AsValueEnumerable().ToLookup(x => x % 3);
+        var expectedLookup = (System.Linq.Lookup<int, int>)xs.ToLookup(x => x % 3);
+
+        // Act - transform each group to a string representation
+        var results = lookup.ApplyResultSelector((key, elements) => $"Key: {key}, Count: {elements.Count()}, Sum: {elements.Sum()}").ToList();
+        var expectedResults = expectedLookup.ApplyResultSelector((key, elements) => $"Key: {key}, Count: {elements.Count()}, Sum: {elements.Sum()}").ToList();
+
+        // Assert
+        results.Count.ShouldBe(expectedResults.Count);
+        results[0].ShouldBe(expectedResults[0]);    
+        results[1].ShouldBe(expectedResults[1]);    
+        results[2].ShouldBe(expectedResults[2]);
+    }
+
+    [Fact]
+    public void ApplyResultSelectorNullSelector()
+    {
+        // Arrange
+        var xs = new[] { 1, 2, 3 };
+        var lookup = (ZLinq.Linq.Lookup<int, int>)xs.AsValueEnumerable().ToLookup(x => x);
+
+        // Act & Assert
+        Should.Throw<ArgumentNullException>(() =>
+        {
+            var result = lookup.ApplyResultSelector<string>(null!).ToList();
+        });
+    }
+
+    [Fact]
+    public void ApplyResultSelectorOnEmptyLookup()
+    {
+        // Arrange
+        var xs = Array.Empty<int>();
+        var lookup = (ZLinq.Linq.Lookup<int, int>)xs.AsValueEnumerable().ToLookup(x => x);
+
+        // Act
+        var results = lookup.ApplyResultSelector((key, elements) => $"Key: {key}, Count: {elements.Count()}").ToList();
+
+        // Assert
+        results.Count.ShouldBe(0);
+    }
+
 }