Introduce Duplicates extension

MoreLinq.Test/DuplicatesTest.cs

@@ -0,0 +1,220 @@
+namespace MoreLinq.Test
+{
+    using System.Collections.Generic;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class DuplicatesTest
+    {
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_Without_Duplicates_Then_Empty_Sequence_Is_Returned()
+        {
+            var stringArray = new[]
+            {
+                "FirstElement",
+                "SecondElement",
+                "ThirdElement"
+            };
+
+            var duplicates = stringArray.Duplicates();
+
+            Assert.That(duplicates, Is.Empty);
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_Projection_Without_Duplicates_Then_Then_Empty_Sequence_Is_Returned()
+        {
+            var dummyClasses = new DummyClass[]
+            {
+                new("FirstElement"),
+                new("SecondElement"),
+                new("ThirdElement")
+            };
+
+            var duplicates = dummyClasses.Duplicates(x => x.ComparableString);
+
+            Assert.That(duplicates, Is.Empty);
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_With_Duplicates_Then_True_Is_Returned()
+        {
+            var stringArray = new[]
+            {
+                "FirstElement",
+                "DUPLICATED_STRING",
+                "DUPLICATED_STRING",
+                "ThirdElement"
+            };
+
+            var duplicates = stringArray.Duplicates();
+
+            Assert.That(duplicates, Contains.Item("DUPLICATED_STRING"));
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_Projection_With_Duplicates_Then_True_Is_Returned()
+        {
+            var dummyClass = new DummyClass("DUPLICATED_STRING");
+            var dummyClasses = new DummyClass[]
+            {
+                new("FirstElement"),
+                dummyClass,
+                dummyClass,
+                new("ThirdElement")
+            };
+
+            var duplicates = dummyClasses.Duplicates(x => x.ComparableString);
+
+            Assert.That(duplicates, Contains.Item(dummyClass));
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_With_Duplicates_Then_It_Does_Not_Iterate_Unnecessary_On_Elements()
+        {
+            var source = MoreEnumerable.From(() => "FirstElement",
+                () => "DUPLICATED_STRING",
+                () => "DUPLICATED_STRING",
+                () => throw new TestException());
+
+            Assert.DoesNotThrow(() => source.Duplicates());
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_Projection_With_Duplicates_Then_It_Does_Not_Iterate_Unnecessary_On_Elements()
+        {
+            var source = MoreEnumerable.From(() => new DummyClass("FirstElement"),
+                () => new DummyClass("DUPLICATED_STRING"),
+                () => new DummyClass("DUPLICATED_STRING"),
+                () => throw new TestException());
+
+            Assert.DoesNotThrow(() => source.Duplicates(x => x.ComparableString));
+        }
+
+        [Test]
+        public void When_Asking_Duplicates_Then_It_Is_Executed_Right_Away()
+        {
+            _ = Assert.Throws<BreakException>(() => new BreakingSequence<string>().Duplicates().Consume());
+        }
+
+        [Test]
+        public void When_Asking_Duplicates_On_Sequence_Projection_Then_It_Is_Executed_Right_Away()
+        {
+            _ = Assert.Throws<BreakException>(() => new BreakingSequence<DummyClass>().Duplicates(x => x.ComparableString).Consume());
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_With_Custom_Always_True_Comparer_Then_True_Is_Returned()
+        {
+            var stringArray = new[]
+            {
+                "FirstElement",
+                "SecondElement",
+                "ThirdElement"
+            };
+
+            var duplicates = stringArray.Duplicates(new DummyStringAlwaysTrueComparer()).ToArray();
+
+            Assert.That(duplicates, Contains.Item(stringArray[1]));
+            Assert.That(duplicates, Contains.Item(stringArray[2]));
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_Projection_With_Custom_Always_True_Comparer_Then_True_Is_Returned()
+        {
+            var dummyClasses = new DummyClass[]
+            {
+                new("FirstElement"),
+                new("SecondElement"),
+                new("ThirdElement")
+            };
+
+            var duplicates = dummyClasses.Duplicates(x => x.ComparableString, new DummyStringAlwaysTrueComparer()).ToArray();
+
+            Assert.That(duplicates, Contains.Item(dummyClasses[1]));
+            Assert.That(duplicates, Contains.Item(dummyClasses[2]));
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_None_Duplicates_Sequence_With_Custom_Always_True_Comparer_Then_True_Is_Returned()
+        {
+            var stringArray = new[]
+            {
+                "FirstElement",
+                "SecondElement",
+                "ThirdElement"
+            };
+
+            var duplicates = stringArray.Duplicates(new DummyStringAlwaysTrueComparer()).ToArray();
+
+            Assert.That(duplicates, Contains.Item(stringArray[1]));
+            Assert.That(duplicates, Contains.Item(stringArray[2]));
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Sequence_With_Custom_Always_False_Comparer_Then_Then_Empty_Sequence_Is_Returned()
+        {
+            var stringArray = new[]
+            {
+                "FirstElement",
+                "SecondElement",
+                "ThirdElement"
+            };
+
+            var duplicates = stringArray.Duplicates(new DummyStringAlwaysFalseComparer());
+
+            Assert.That(duplicates, Is.Empty);
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Multiple_Duplicates_Sequence_With_Custom_Always_False_Comparer_Then_Then_Empty_Sequence_Is_Returned()
+        {
+            var stringArray = new[]
+            {
+                "DUPLICATED_STRING",
+                "DUPLICATED_STRING",
+                "DUPLICATED_STRING"
+            };
+
+            var duplicates = stringArray.Duplicates(new DummyStringAlwaysFalseComparer());
+
+            Assert.That(duplicates, Is.Empty);
+        }
+
+        [Test]
+        public void When_Asking_For_Duplicates_On_Multiple_Duplicates_Sequence_Projection_With_Custom_Always_False_Comparer_Then_Then_Empty_Sequence_Is_Returned()
+        {
+            var dummyClasses = new DummyClass[]
+            {
+                new("DUPLICATED_STRING"),
+                new("DUPLICATED_STRING"),
+                new("DUPLICATED_STRING")
+            };
+
+            var duplicates = dummyClasses.Duplicates(x => x.ComparableString, new DummyStringAlwaysFalseComparer());
+
+            Assert.That(duplicates, Is.Empty);
+        }
+
+        sealed class DummyClass
+        {
+            public string ComparableString { get; }
+
+            public DummyClass(string comparableString) => ComparableString = comparableString;
+        }
+
+        sealed class DummyStringAlwaysTrueComparer : IEqualityComparer<string>
+        {
+            public bool Equals(string? x, string? y) => true;
+
+            public int GetHashCode(string obj) => 0;
+        }
+
+        sealed class DummyStringAlwaysFalseComparer : IEqualityComparer<string>
+        {
+            public bool Equals(string? x, string? y) => false;
+
+            public int GetHashCode(string obj) => 0;
+        }
+    }
+}

MoreLinq/Duplicates.cs

@@ -0,0 +1,69 @@
+namespace MoreLinq
+{
+    using System;
+    using System.Collections.Generic;
+
+    static partial class MoreEnumerable
+    {
+        /// <summary>
+        ///   Returns all duplicated elements of the given source.
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+        /// <returns>all elements that are duplicated.</returns>
+        public static IEnumerable<T> Duplicates<T>(this IEnumerable<T> source)
+            => Duplicates(source, EqualityComparer<T>.Default);
+
+        /// <summary>
+        ///   Returns all duplicated elements of the given source, using the specified element equality comparer.
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
+        /// If null, the default equality comparer for <c>TSource</c> is used.</param>
+        /// <typeparam name="T">The type of the elements in the source sequence</typeparam>
+        /// <returns>all elements of the source sequence that are duplicated, based on the provided equality comparer</returns>
+        public static IEnumerable<T> Duplicates<T>(this IEnumerable<T> source, IEqualityComparer<T>? comparer)
+            => Duplicates(source, IdFn, comparer);
+
+        /// <summary>
+        ///   Returns all duplicated elements of the given source, using the specified element equality comparer
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <param name="keySelector">Projection for determining duplication</param>
+        /// <typeparam name="TSource">Type of the source sequence</typeparam>
+        /// <typeparam name="TKey">Type of the projected element</typeparam>
+        /// <returns>all elements of the source sequence that are duplicated, based on the provided equality comparer</returns>
+        public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
+            => Duplicates(source, keySelector, EqualityComparer<TKey>.Default);
+
+        /// <summary>
+        ///   Returns all duplicated elements of the given source, using the specified element equality comparer
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <param name="keySelector">Projection for determining duplication</param>
+        /// <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
+        /// If null, the default equality comparer for <c>TSource</c> is used.</param>
+        /// <typeparam name="TSource">Type of the source sequence</typeparam>
+        /// <typeparam name="TKey">Type of the projected element</typeparam>
+        /// <returns>all elements of the source sequence that are duplicated, based on the provided equality comparer</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is null.</exception>
+        public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
+        {
+            if (source is null) throw new ArgumentNullException(nameof(source));
+            if (keySelector is null) throw new ArgumentNullException(nameof(keySelector));
+
+            return GetDuplicates();
+
+            IEnumerable<TSource> GetDuplicates()
+            {
+                var enumeratedElements = new HashSet<TKey>(comparer);
+                foreach (var element in source)
+                {
+                    if (enumeratedElements.Add(keySelector(element)) is false)
+                        yield return element;
+                }
+            }
+        }
+    }
+}

MoreLinq/Extensions.g.cs

@@ -1283,6 +1283,59 @@ public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TS
 
     }
 
+    /// <summary><c>Duplicates</c> extension.</summary>
+
+    [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]
+    public static partial class DuplicatesExtension
+    {
+        /// <summary>
+        ///   Returns all duplicated elements of the given source.
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <typeparam name="T">The type of the elements in the source sequence.</typeparam>
+        /// <returns>all elements that are duplicated.</returns>
+        public static IEnumerable<T> Duplicates<T>(this IEnumerable<T> source)
+            => MoreEnumerable.Duplicates(source);
+
+        /// <summary>
+        ///   Returns all duplicated elements of the given source, using the specified element equality comparer.
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
+        /// If null, the default equality comparer for <c>TSource</c> is used.</param>
+        /// <typeparam name="T">The type of the elements in the source sequence</typeparam>
+        /// <returns>all elements of the source sequence that are duplicated, based on the provided equality comparer</returns>
+        public static IEnumerable<T> Duplicates<T>(this IEnumerable<T> source, IEqualityComparer<T>? comparer)
+            => MoreEnumerable.Duplicates(source, comparer);
+
+        /// <summary>
+        ///   Returns all duplicated elements of the given source, using the specified element equality comparer
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <param name="keySelector">Projection for determining duplication</param>
+        /// <typeparam name="TSource">Type of the source sequence</typeparam>
+        /// <typeparam name="TKey">Type of the projected element</typeparam>
+        /// <returns>all elements of the source sequence that are duplicated, based on the provided equality comparer</returns>
+        public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
+            => MoreEnumerable.Duplicates(source, keySelector);
+
+        /// <summary>
+        ///   Returns all duplicated elements of the given source, using the specified element equality comparer
+        /// </summary>
+        /// <param name="source">source sequence.</param>
+        /// <param name="keySelector">Projection for determining duplication</param>
+        /// <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
+        /// If null, the default equality comparer for <c>TSource</c> is used.</param>
+        /// <typeparam name="TSource">Type of the source sequence</typeparam>
+        /// <typeparam name="TKey">Type of the projected element</typeparam>
+        /// <returns>all elements of the source sequence that are duplicated, based on the provided equality comparer</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="keySelector"/> is null.</exception>
+        public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
+            => MoreEnumerable.Duplicates(source, keySelector, comparer);
+
+    }
+
     /// <summary><c>EndsWith</c> extension.</summary>
 
     [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")]

MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt

@@ -1 +1,10 @@
 #nullable enable
+MoreLinq.Extensions.DuplicatesExtension
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!

MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt

@@ -1 +1,10 @@
 #nullable enable
+MoreLinq.Extensions.DuplicatesExtension
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Duplicates<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
+static MoreLinq.MoreEnumerable.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
+static MoreLinq.MoreEnumerable.Duplicates<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!