Add SortedSet.AsValueEnumerable

Author: neuecc

src/ZLinq/Linq/AsValueEnumerable.cs

@@ -85,6 +85,11 @@ public static ValueEnumerable<FromHashSet<T>, T> AsValueEnumerable<T>(this HashS
             return new(new(Throws.IfNull(source)));
         }
 
+        public static ValueEnumerable<FromSortedSet<T>, T> AsValueEnumerable<T>(this SortedSet<T> source)
+        {
+            return new(new(Throws.IfNull(source)));
+        }
+
 #if NET8_0_OR_GREATER
 
         public static ValueEnumerable<FromImmutableArray<T>, T> AsValueEnumerable<T>(this ImmutableArray<T> source)
@@ -974,6 +979,56 @@ public void Dispose()
         }
     }
 
+    [StructLayout(LayoutKind.Auto)]
+    public struct FromSortedSet<T>(SortedSet<T> source) : IValueEnumerator<T>
+    {
+        bool isInit;
+        SortedSet<T>.Enumerator enumerator;
+
+        // for Contains, need to check ICollection of IEqualityComparer due to compatibility
+        internal SortedSet<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();
+            }
+        }
+    }
+
 #if NET8_0_OR_GREATER
     [StructLayout(LayoutKind.Auto)]
     public struct FromImmutableArray<T>(ImmutableArray<T> source) : IValueEnumerator<T>

src/ZLinq/Linq/Contains.cs

@@ -29,6 +29,12 @@ public static Boolean Contains<TSource>(this ValueEnumerable<FromHashSet<TSource
             return innerCollection.Contains(value);
         }
 
+        public static Boolean Contains<TSource>(this ValueEnumerable<FromSortedSet<TSource>, TSource> source, TSource value)
+        {
+            var innerCollection = source.Enumerator.GetSource();
+            return innerCollection.Contains(value);
+        }
+
         public static Boolean Contains<TEnumerator, TSource>(this ValueEnumerable<TEnumerator, TSource> source, TSource value)
     where TEnumerator : struct, IValueEnumerator<TSource>
 #if NET9_0_OR_GREATER

tests/ZLinq.Tests/Linq/AsValueEnumerableTest.cs

@@ -330,6 +330,37 @@ public void FromHashSet_BasicFunctionality()
             resultArray.ShouldBe(source.ToArray(), ignoreOrder: true);
         }
 
+        [Fact]
+        public void FromSortedSet_BasicFunctionality()
+        {
+            // Arrange
+            var source = new SortedSet<int>(new[] { 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 FromSortedSet_ContainsOptimization()
+        {
+            // Arrange
+            var source = new SortedSet<int>(new[] { 1, 2, 3, 4, 5 });
+            var result = source.AsValueEnumerable();
+
+            // Act & Assert
+            result.Contains(3).ShouldBeTrue();
+            result.Contains(6).ShouldBeFalse();
+        }
+
 #if NET8_0_OR_GREATER
         [Fact]
         public void FromImmutableArray_BasicFunctionality()