Merge pull request Cysharp#173 from prozolic/FromImmutableHashSet

Add ImmutableHashSet.AsValueEnumerable

Author: neuecc

src/ZLinq/Linq/AsValueEnumerable.cs

@@ -95,6 +95,11 @@ public static ValueEnumerable<FromSortedSet<T>, T> AsValueEnumerable<T>(this Sor
         public static ValueEnumerable<FromImmutableArray<T>, T> AsValueEnumerable<T>(this ImmutableArray<T> source)
         {
             return new(new(source));
+        }
+
+        public static ValueEnumerable<FromImmutableHashSet<T>, T> AsValueEnumerable<T>(this ImmutableHashSet<T> source)
+        {
+            return new(new(Throws.IfNull(source)));
         }
 
 #endif
@@ -1073,10 +1078,60 @@ public bool TryGetNext(out T current)
         public void Dispose()
         {
         }
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    public struct FromImmutableHashSet<T>(ImmutableHashSet<T> source) : IValueEnumerator<T>
+    {
+        bool isInit;
+        ImmutableHashSet<T>.Enumerator enumerator;
+
+        internal ImmutableHashSet<T> GetSource() => source;
+
+        public bool TryGetNonEnumeratedCount(out int count)
+        {
+            count = source.Count;
+            return true;
+        }
+
+        public bool TryGetSpan(out ReadOnlySpan<T> span)
+        {
+            span = default;
+            return false;
+        }
+
+        public bool TryCopyTo(Span<T> destination, Index offset) => false;
+
+        public bool TryGetNext(out T current)
+        {
+            if (!isInit)
+            {
+                isInit = true;
+                enumerator = source.GetEnumerator();
+            }
+
+            if (enumerator.MoveNext())
+            {
+                current = enumerator.Current;
+                return true;
+            }
+
+            Unsafe.SkipInit(out current);
+            return false;
+        }
+
+        public void Dispose()
+        {
+            if (isInit)
+            {
+                enumerator.Dispose();
+            }
+        }
     }
 
 #endif
 
+
 #if NET9_0_OR_GREATER
 
     [StructLayout(LayoutKind.Auto)]

src/ZLinq/Linq/Contains.cs

@@ -30,10 +30,19 @@ public static Boolean Contains<TSource>(this ValueEnumerable<FromHashSet<TSource
         }
 
         public static Boolean Contains<TSource>(this ValueEnumerable<FromSortedSet<TSource>, TSource> source, TSource value)
+        {
+            var innerCollection = source.Enumerator.GetSource();
+            return innerCollection.Contains(value);
+        }
+
+#if NET8_0_OR_GREATER
+
+        public static Boolean Contains<TSource>(this ValueEnumerable<FromImmutableHashSet<TSource>, TSource> source, TSource value)
         {
             var innerCollection = source.Enumerator.GetSource();
             return innerCollection.Contains(value);
         }
+#endif
 
         public static Boolean Contains<TEnumerator, TSource>(this ValueEnumerable<TEnumerator, TSource> source, TSource value)
     where TEnumerator : struct, IValueEnumerator<TSource>

tests/ZLinq.Tests/Linq/AsValueEnumerableTest.cs

@@ -380,7 +380,39 @@ public void FromImmutableArray_BasicFunctionality()
 
             var resultArray = result.ToArray();
             resultArray.ShouldBe(source.ToArray());
+        }
+
+        [Fact]
+        public void FromImmutableHashSet_BasicFunctionality()
+        {
+            // Arrange
+            var source = ImmutableHashSet.Create(5, 2, 1, 4, 3);
+
+            // Act
+            var result = source.AsValueEnumerable();
+
+            // Assert
+            result.TryGetNonEnumeratedCount(out var count).ShouldBeTrue();
+            count.ShouldBe(source.Count);
+
+            result.TryGetSpan(out var span).ShouldBeFalse();
+
+            var resultArray = result.ToArray();
+            resultArray.ShouldBe(new[] { 1, 2, 3, 4, 5 }); // SortedSet should be ordered
         }
+
+        [Fact]
+        public void FromImmutableHashSet_ContainsOptimization()
+        {
+            // Arrange
+            var source = ImmutableHashSet.Create(5, 2, 1, 4, 3);
+            var result = source.AsValueEnumerable();
+
+            // Act & Assert
+            result.Contains(3).ShouldBeTrue();
+            result.Contains(6).ShouldBeFalse();
+        }
+
 #endif
 
 #if NET9_0_OR_GREATER