From ae75e712a5cb0ab5d532a7b81133dfcb62f2230d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A1ra=20El-Saig?= <sara.el-saig@lombiq.com>
Date: Mon, 22 Jul 2024 20:48:01 +0200
Subject: [PATCH 1/4] Add Fork extension method.

---
 .../Extensions/EnumerableExtensions.cs        | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
index df10065d..b0f8dffa 100644
--- a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
+++ b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
@@ -404,4 +404,30 @@ public static Task<TResult> InvokeFirstOrDefaultAsync<TItem, TResult>(
         enumerable.FirstOrDefault() is { } item
             ? funcAsync(item)
             : Task.FromResult(default(TResult));
+
+    /// <summary>
+    /// Splits the provided <paramref name="enumerable"/> into two.
+    /// </summary>
+    /// <param name="enumerable">The original collection to be tested.</param>
+    /// <param name="leftPredicate">
+    /// Tests each item of <paramref name="enumerable"/>. If returns <see langword="true"/>, the
+    /// item is added to the left collection, otherwise added to the right collection.
+    /// </param>
+    /// <typeparam name="T">The type of the items in <paramref name="enumerable"/>.</typeparam>
+    /// <returns>A tuple of two collections. Each item in <paramref name="enumerable"/> is in one of them.</returns>
+    public static (IList<T> Left, IList<T> Right) Fork<T>(
+        this IEnumerable<T> enumerable,
+        Func<T, bool> leftPredicate)
+    {
+        var left = new List<T>();
+        var right = new List<T>();
+
+        foreach (var item in enumerable)
+        {
+            var target = leftPredicate(item) ? left : right;
+            target.Add(item);
+        }
+
+        return (left, right);
+    }
 }

From 1b64bdd56ae0f8f2e7f612a6487b900fc0a90745 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A1ra=20El-Saig?= <sara.el-saig@lombiq.com>
Date: Mon, 22 Jul 2024 21:13:10 +0200
Subject: [PATCH 2/4] Mark EnumerableExtensions.cs with `#nullable enable`.

---
 .../Extensions/EnumerableExtensions.cs        | 42 +++++++++++--------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
index b0f8dffa..0062fa31 100644
--- a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
+++ b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
@@ -1,3 +1,5 @@
+#nullable enable
+
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
@@ -39,7 +41,7 @@ public static TAccumulate AggregateSeed<TSource, TAccumulate>(
     /// <param name="beforeFirst">The action to perform before the first item's <paramref name="action"/>.</param>
     /// <typeparam name="T">The type of the items in <paramref name="source"/>.</typeparam>
     /// <returns><see langword="true"/> if the <paramref name="source"/> had at least one item.</returns>
-    public static bool ForEach<T>(this IEnumerable<T> source, Action<T> action, Action<T> beforeFirst = null)
+    public static bool ForEach<T>(this IEnumerable<T> source, Action<T> action, Action<T>? beforeFirst = null)
     {
         bool any = false;
 
@@ -171,9 +173,9 @@ public static IList<T> AsList<T>(this IEnumerable<T> collection) =>
     public static IEnumerable<TOut> SelectWhere<TIn, TOut>(
         this IEnumerable<TIn> collection,
         Func<TIn, TOut> select,
-        Func<TOut, bool> where = null)
+        Func<TOut, bool>? where = null)
     {
-        foreach (var item in collection ?? [])
+        foreach (var item in collection)
         {
             var converted = select(item);
             if (where?.Invoke(converted) ?? converted is not null) yield return converted;
@@ -192,6 +194,7 @@ public static Dictionary<TKey, TValue> ToDictionaryOverwrite<TIn, TKey, TValue>(
         this IEnumerable<TIn> collection,
         Func<TIn, TKey> keySelector,
         Func<TIn, TValue> valueSelector)
+        where TKey : notnull
     {
         var dictionary = new Dictionary<TKey, TValue>();
         foreach (var item in collection) dictionary[keySelector(item)] = valueSelector(item);
@@ -208,7 +211,8 @@ public static Dictionary<TKey, TValue> ToDictionaryOverwrite<TIn, TKey, TValue>(
         Justification = "This is the point of the method.")]
     public static Dictionary<TKey, TIn> ToDictionaryOverwrite<TIn, TKey>(
         this IEnumerable<TIn> collection,
-        Func<TIn, TKey> keySelector) =>
+        Func<TIn, TKey> keySelector)
+        where TKey : notnull =>
         ToDictionaryOverwrite(collection, keySelector, item => item);
 
     /// <summary>
@@ -221,7 +225,7 @@ public static Dictionary<TKey, TIn> ToDictionaryOverwrite<TIn, TKey>(
     /// after grouping.
     /// </para>
     /// </remarks>
-    public static IEnumerable<TItem> Unique<TItem, TKey>(
+    public static IEnumerable<TItem?> Unique<TItem, TKey>(
         this IEnumerable<TItem> collection,
         Func<TItem, TKey> keySelector) =>
         collection.GroupBy(keySelector).Select(group => group.FirstOrDefault());
@@ -230,7 +234,7 @@ public static IEnumerable<TItem> Unique<TItem, TKey>(
     /// Returns the <paramref name="collection"/> without any duplicate items picking the first of each when sorting by
     /// <paramref name="orderBySelector"/>.
     /// </summary>
-    public static IEnumerable<TItem> Unique<TItem, TKey, TOrder>(
+    public static IEnumerable<TItem?> Unique<TItem, TKey, TOrder>(
         this IEnumerable<TItem> collection,
         Func<TItem, TKey> keySelector,
         Func<TItem, TOrder> orderBySelector) =>
@@ -242,7 +246,7 @@ public static IEnumerable<TItem> Unique<TItem, TKey, TOrder>(
     /// Returns the <paramref name="collection"/> without any duplicate items picking the last of each when sorting by
     /// <paramref name="orderBySelector"/>.
     /// </summary>
-    public static IEnumerable<TItem> UniqueDescending<TItem, TKey, TOrder>(
+    public static IEnumerable<TItem?> UniqueDescending<TItem, TKey, TOrder>(
         this IEnumerable<TItem> collection,
         Func<TItem, TKey> keySelector,
         Func<TItem, TOrder> orderBySelector) =>
@@ -254,11 +258,13 @@ public static IEnumerable<TItem> UniqueDescending<TItem, TKey, TOrder>(
     /// Returns a string that joins the string collection. It excludes null or empty items if there are any.
     /// </summary>
     /// <returns>The concatenated texts if there are any nonempty, otherwise <see langword="null"/>.</returns>
-    public static string JoinNotNullOrEmpty(this IEnumerable<string> strings, string separator = ",")
+    public static string? JoinNotNullOrEmpty(this IEnumerable<string>? strings, string separator = ",")
     {
-        var filteredStrings = strings?.Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
+        var filteredStrings = (strings ?? [])
+            .Where(text => !string.IsNullOrWhiteSpace(text))
+            .ToList();
 
-        return filteredStrings?.Count > 0
+        return filteredStrings.Count > 0
             ? string.Join(separator, filteredStrings)
             : null;
     }
@@ -271,7 +277,7 @@ public static string JoinNotNullOrEmpty(this IEnumerable<string> strings, string
     /// <returns>
     /// A new <see cref="string"/> that concatenates all values with the <paramref name="separator"/> provided.
     /// </returns>
-    public static string Join(this IEnumerable<string> values, string separator = " ") =>
+    public static string Join(this IEnumerable<string>? values, string separator = " ") =>
         string.Join(separator, values ?? []);
 
     /// <summary>
@@ -293,14 +299,14 @@ public static IEnumerable<T> WhereNot<T>(this IEnumerable<T> collection, Func<T,
     /// Returns <paramref name="collection"/> if it's not <see langword="null"/>, otherwise <see
     /// cref="Enumerable.Empty{TResult}"/>.
     /// </summary>
-    public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> collection) =>
+    public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T>? collection) =>
         collection ?? [];
 
     /// <summary>
     /// Returns <paramref name="array"/> if it's not <see langword="null"/>, otherwise <see
     /// cref="Array.Empty{TResult}"/>.
     /// </summary>
-    public static IEnumerable<T> EmptyIfNull<T>(this T[] array) =>
+    public static IEnumerable<T> EmptyIfNull<T>(this T[]? array) =>
         array ?? [];
 
     /// <summary>
@@ -333,7 +339,7 @@ public static IEnumerable<TResult> Select<TKey, TValue, TResult>(
     /// Similar to <see cref="Enumerable.Cast{TResult}"/>, but it checks if the types are correct first, and filters out
     /// the ones that couldn't be cast. The optional <paramref name="predicate"/> can filter the cast items.
     /// </summary>
-    public static IEnumerable<T> CastWhere<T>(this IEnumerable enumerable, Func<T, bool> predicate = null)
+    public static IEnumerable<T> CastWhere<T>(this IEnumerable enumerable, Func<T, bool>? predicate = null)
     {
         if (enumerable is IEnumerable<T> alreadyCast)
         {
@@ -342,7 +348,7 @@ public static IEnumerable<T> CastWhere<T>(this IEnumerable enumerable, Func<T, b
                 : alreadyCast.Where(predicate);
         }
 
-        static IEnumerable<T> Iterate(IEnumerable enumerable, Func<T, bool> predicate)
+        static IEnumerable<T> Iterate(IEnumerable enumerable, Func<T, bool>? predicate)
         {
             foreach (var item in enumerable)
             {
@@ -398,12 +404,12 @@ public static Task InvokeFirstOrCompletedAsync<T>(this IEnumerable<T> enumerable
     /// If the <paramref name="enumerable"/> is not empty, invokes the <paramref name="funcAsync"/> on the first item
     /// and returns its result, otherwise returns <see langword="default"/> for <typeparamref name="TResult"/>.
     /// </summary>
-    public static Task<TResult> InvokeFirstOrDefaultAsync<TItem, TResult>(
+    public static Task<TResult?> InvokeFirstOrDefaultAsync<TItem, TResult>(
         this IEnumerable<TItem> enumerable,
-        Func<TItem, Task<TResult>> funcAsync) =>
+        Func<TItem, Task<TResult?>> funcAsync) =>
         enumerable.FirstOrDefault() is { } item
             ? funcAsync(item)
-            : Task.FromResult(default(TResult));
+            : Task.FromResult(default(TResult?));
 
     /// <summary>
     /// Splits the provided <paramref name="enumerable"/> into two.

From 66cffff223d91db7f9cdc5e99e702aa678e5e2ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A1ra=20El-Saig?= <sara.el-saig@lombiq.com>
Date: Mon, 22 Jul 2024 21:14:44 +0200
Subject: [PATCH 3/4] Fork's input can be null.

---
 .../Extensions/EnumerableExtensions.cs                        | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
index 0062fa31..251dad82 100644
--- a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
+++ b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
@@ -422,12 +422,14 @@ public static Task InvokeFirstOrCompletedAsync<T>(this IEnumerable<T> enumerable
     /// <typeparam name="T">The type of the items in <paramref name="enumerable"/>.</typeparam>
     /// <returns>A tuple of two collections. Each item in <paramref name="enumerable"/> is in one of them.</returns>
     public static (IList<T> Left, IList<T> Right) Fork<T>(
-        this IEnumerable<T> enumerable,
+        this IEnumerable<T>? enumerable,
         Func<T, bool> leftPredicate)
     {
         var left = new List<T>();
         var right = new List<T>();
 
+        if (enumerable is null) return (left, right);
+
         foreach (var item in enumerable)
         {
             var target = leftPredicate(item) ? left : right;

From 49a301993ad7b70f6072e9145a04d4e00311c2c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A1ra=20El-Saig?= <sara.el-saig@lombiq.com>
Date: Tue, 23 Jul 2024 11:14:58 +0200
Subject: [PATCH 4/4] Split SelectWhere into two methods for better nullable
 representation.

---
 .../Extensions/EnumerableExtensions.cs        | 21 +++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
index 251dad82..a304a710 100644
--- a/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
+++ b/Lombiq.HelpfulLibraries.Common/Extensions/EnumerableExtensions.cs
@@ -167,18 +167,31 @@ public static IList<T> AsList<T>(this IEnumerable<T> collection) =>
 
     /// <summary>
     /// Transforms the specified <paramref name="collection"/> with the <paramref name="select"/> function and returns
-    /// the items that are not null. Or if the <paramref name="where"/> function is given then those that return <see
-    /// langword="true"/> with it.
+    /// the items that return <see langword="true"/> when passed to the <paramref name="where"/> function.
     /// </summary>
     public static IEnumerable<TOut> SelectWhere<TIn, TOut>(
         this IEnumerable<TIn> collection,
         Func<TIn, TOut> select,
-        Func<TOut, bool>? where = null)
+        Func<TOut, bool> where)
     {
         foreach (var item in collection)
         {
             var converted = select(item);
-            if (where?.Invoke(converted) ?? converted is not null) yield return converted;
+            if (where.Invoke(converted)) yield return converted;
+        }
+    }
+
+    /// <summary>
+    /// Transforms the specified <paramref name="collection"/> with the <paramref name="select"/> function and returns
+    /// the items that are not null.
+    /// </summary>
+    public static IEnumerable<TOut> SelectWhere<TIn, TOut>(this IEnumerable<TIn> collection, Func<TIn, TOut?> select)
+        where TOut : notnull
+    {
+        foreach (var item in collection)
+        {
+            var converted = select(item);
+            if (converted is not null) yield return converted;
         }
     }