[Distinct] Use DefaultComparer for some ValueType.

Author: reegeek

src/StructLinq.Tests/DistinctTests.cs

@@ -7,12 +7,12 @@
 namespace StructLinq.Tests
 {
     public class DistinctTests : AbstractEnumerableTests<int,
-        DistinctEnumerable<int, RangeEnumerable, RangeEnumerator, EqualityComparer<int>>,
-        DistinctEnumerator<int, RangeEnumerator, EqualityComparer<int>>>
+        DistinctEnumerable<int, RangeEnumerable, RangeEnumerator, DefaultStructEqualityComparer>,
+        DistinctEnumerator<int, RangeEnumerator, DefaultStructEqualityComparer>>
     {
-        protected override DistinctEnumerable<int, RangeEnumerable, RangeEnumerator, EqualityComparer<int>> Build(int size)
+        protected override DistinctEnumerable<int, RangeEnumerable, RangeEnumerator, DefaultStructEqualityComparer> Build(int size)
         {
-            var selectEnumerable = StructEnumerable.Range(-1, size).Distinct(x=>x);
+            var selectEnumerable = StructEnumerable.Range(-1, size).Distinct(x => x);
             return selectEnumerable;
         }
 
@@ -26,7 +26,7 @@ public void ShouldEquals()
             var value = Enumerable.Range(0, 100)
                 .Select(x => x % 10)
                 .ToStructEnumerable()
-                .Distinct(x=> x)
+                .Distinct(x => x)
                 .ToEnumerable();
             Assert.Equal(expected, value);
         }

src/StructLinq.Tests/RefDistinctTests.cs

@@ -6,12 +6,12 @@
 namespace StructLinq.Tests
 {
     public class RefDistinctTests : AbstractRefEnumerableTests<int,
-        RefDistinctEnumerable<int, ArrayRefEnumerable<int>, ArrayRefStructEnumerator<int>, IInEqualityComparer<int>>,
-        RefDistinctEnumerator<int, ArrayRefStructEnumerator<int>, IInEqualityComparer<int>>>
+        RefDistinctEnumerable<int, ArrayRefEnumerable<int>, ArrayRefStructEnumerator<int>, DefaultStructInEqualityComparer>,
+        RefDistinctEnumerator<int, ArrayRefStructEnumerator<int>, DefaultStructInEqualityComparer>>
     {
-        protected override RefDistinctEnumerable<int, ArrayRefEnumerable<int>, ArrayRefStructEnumerator<int>, IInEqualityComparer<int>> Build(int size)
+        protected override RefDistinctEnumerable<int, ArrayRefEnumerable<int>, ArrayRefStructEnumerator<int>, DefaultStructInEqualityComparer> Build(int size)
         {
-            var selectEnumerable = Enumerable.Range(-1, size).ToArray().ToRefStructEnumerable().Distinct(x=>x);
+            var selectEnumerable = Enumerable.Range(-1, size).ToArray().ToRefStructEnumerable().Distinct(x => x);
             return selectEnumerable;
         }
 
@@ -26,7 +26,7 @@ public void ShouldEquals()
                                   .Select(x => x % 10)
                                   .ToArray()
                                   .ToRefStructEnumerable()
-                                  .Distinct(x=> x)
+                                  .Distinct(x => x)
                                   .ToEnumerable();
             Assert.Equal(expected, value);
         }

src/StructLinq/Distinct/RefDistinctEnumerable.cs

@@ -7,7 +7,7 @@ public struct RefDistinctEnumerable<T, TEnumerable, TEnumerator, TComparer> : IR
         RefDistinctEnumerator<T, TEnumerator, TComparer>>
         where TComparer : IInEqualityComparer<T>
         where TEnumerator : struct, IRefStructEnumerator<T>
-        where TEnumerable : struct, IRefStructEnumerable<T, TEnumerator>
+        where TEnumerable : IRefStructEnumerable<T, TEnumerator>
 
     {
         private TEnumerable enumerable;

src/StructLinq/Distinct/StructEnumerable.Distinct.cs

@@ -147,6 +147,23 @@ public static RefDistinctEnumerable<T, TEnumerable, TEnumerator, IInEqualityComp
             return enumerable.Distinct(InEqualityComparer<T>.Default, _);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static RefDistinctEnumerable<T, IRefStructEnumerable<T, TEnumerator>, TEnumerator, IInEqualityComparer<T>> Distinct<T,TEnumerator>(
+            this IRefStructEnumerable<T, TEnumerator> enumerable,
+            IInEqualityComparer<T> comparer)
+            where TEnumerator : struct, IRefStructEnumerator<T>
+        {
+            return new RefDistinctEnumerable<T, IRefStructEnumerable<T, TEnumerator>, TEnumerator, IInEqualityComparer<T>>(ref enumerable, comparer, 0, ArrayPool<int>.Shared, ArrayPool<Slot<T>>.Shared);
+
+        }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static RefDistinctEnumerable<T, IRefStructEnumerable<T, TEnumerator>, TEnumerator, IInEqualityComparer<T>> Distinct<T, TEnumerator>(
+            this IRefStructEnumerable<T, TEnumerator> enumerable)
+            where TEnumerator : struct, IRefStructEnumerator<T>
+        {
+            var equalityComparer = InEqualityComparer<T>.Default;
+            return new RefDistinctEnumerable<T, IRefStructEnumerable<T, TEnumerator>, TEnumerator, IInEqualityComparer<T>>(ref enumerable, equalityComparer, 0, ArrayPool<int>.Shared, ArrayPool<Slot<T>>.Shared);
+        }
     }
 }