Annotate nullability of reference types

.travis.yml

@@ -8,7 +8,7 @@ solution: MoreLinq.sln
 mono: 5.0.1
 dist: xenial
 sudo: required
-dotnet: 3.1.102
+dotnet: 3.1.300
 env:
   - CONFIGURATION=Debug
   - CONFIGURATION=Release

MoreLinq/Assert.cs

@@ -60,7 +60,7 @@ public static IEnumerable<TSource> Assert<TSource>(this IEnumerable<TSource> sou
         /// </remarks>
 
         public static IEnumerable<TSource> Assert<TSource>(this IEnumerable<TSource> source,
-            Func<TSource, bool> predicate, Func<TSource, Exception> errorSelector)
+            Func<TSource, bool> predicate, Func<TSource, Exception>? errorSelector)
         {
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (predicate == null) throw new ArgumentNullException(nameof(predicate));

MoreLinq/Batch.cs

@@ -125,7 +125,7 @@ public static IEnumerable<TResult> Batch<TSource, TResult>(this IEnumerable<TSou
 
                 IEnumerable<TResult> Batch(int size)
                 {
-                    TSource[] bucket = null;
+                    TSource[]? bucket = null;
                     var count = 0;
 
                     foreach (var item in source)

MoreLinq/Collections/Dictionary.cs

@@ -0,0 +1,82 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2020 Atif Aziz, Leandro F. Vieira (leandromoh). All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+namespace MoreLinq.Collections
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// A minimal <see cref="System.Collections.Generic.Dictionary{TKey,TValue}"/> wrapper that
+    /// allows null keys when <typeparamref name="TKey"/> is a
+    /// reference type.
+    /// </summary>
+
+    // Add members if and when needed to keep coverage.
+
+    struct Dictionary<TKey, TValue>
+    {
+        readonly System.Collections.Generic.Dictionary<TKey, TValue> _dict;
+        (bool, TValue) _null;
+
+        public Dictionary(IEqualityComparer<TKey> comparer) : this()
+        {
+            _dict = new System.Collections.Generic.Dictionary<TKey, TValue>(comparer);
+            _null = default;
+        }
+
+        public TValue this[TKey key]
+        {
+            set
+            {
+                DefaultGuard();
+
+                if (key is null)
+                    _null = (true, value);
+                else
+                    _dict[key] = value;
+            }
+        }
+
+        public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
+        {
+            DefaultGuard();
+
+            if (key is null)
+            {
+                switch (_null)
+                {
+                    case (true, {} v):
+                        value = v;
+                        return true;
+                    case (false, _):
+                        value = default!;
+                        return false;
+                }
+            }
+
+            return _dict.TryGetValue(key, out value);
+        }
+
+        void DefaultGuard()
+        {
+            if (_dict is null)
+                throw new InvalidOperationException();
+        }
+    }
+}

MoreLinq/CountBy.cs

@@ -50,7 +50,7 @@ public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this I
         /// If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
         /// <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
 
-        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
+        public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
         {
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (keySelector == null) throw new ArgumentNullException(nameof(keySelector));
@@ -78,51 +78,35 @@ public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this I
 
                 void Loop(IEqualityComparer<TKey> cmp)
                 {
-                    var dic = new Dictionary<TKey, int>(cmp);
-                    var nullIndex = (int?) null;
-
-                    bool TryGetIndex(TKey key, out int i)
-                    {
-                        if (key == null)
-                        {
-                            i = nullIndex.GetValueOrDefault();
-                            return nullIndex.HasValue;
-                        }
-
-                        return dic.TryGetValue(key, out i);
-                    }
+                    var dic = new Collections.Dictionary<TKey, int>(cmp);
 
                     keys = new List<TKey>();
                     counts = new List<int>();
-                    var havePrevKey = false;
-                    var prevKey = default(TKey);
+                    (bool, TKey) prevKey = default;
                     var index = 0;
 
                     foreach (var item in source)
                     {
                         var key = keySelector(item);
 
                         if (// key same as the previous? then re-use the index
-                            havePrevKey && cmp.GetHashCode(prevKey) == cmp.GetHashCode(key)
-                                         && cmp.Equals(prevKey, key)
+                            prevKey is (true, {} pk)
+                                && cmp.GetHashCode(pk) == cmp.GetHashCode(key)
+                                && cmp.Equals(pk, key)
                             // otherwise try & find index of the key
-                            || TryGetIndex(key, out index))
+                            || dic.TryGetValue(key, out index))
                         {
                             counts[index]++;
                         }
                         else
                         {
                             index = keys.Count;
-                            if (key != null)
-                                dic[key] = index;
-                            else
-                                nullIndex = index;
+                            dic[key] = index;
                             keys.Add(key);
                             counts.Add(1);
                         }
 
-                        prevKey = key;
-                        havePrevKey = true;
+                        prevKey = (true, key);
                     }
                 }
             }

MoreLinq/Delegating.cs

@@ -33,14 +33,14 @@ public static IDisposable Disposable(Action delegatee) =>
             new DelegatingDisposable(delegatee);
 
         public static IObserver<T> Observer<T>(Action<T> onNext,
-                                               Action<Exception> onError = null,
-                                               Action onCompleted = null) =>
+                                               Action<Exception>? onError = null,
+                                               Action? onCompleted = null) =>
             new DelegatingObserver<T>(onNext, onError, onCompleted);
     }
 
     sealed class DelegatingDisposable : IDisposable
     {
-        Action _delegatee;
+        Action? _delegatee;
 
         public DelegatingDisposable(Action delegatee) =>
             _delegatee = delegatee ?? throw new ArgumentNullException(nameof(delegatee));
@@ -57,12 +57,12 @@ public void Dispose()
     sealed class DelegatingObserver<T> : IObserver<T>
     {
         readonly Action<T> _onNext;
-        readonly Action<Exception> _onError;
-        readonly Action _onCompleted;
+        readonly Action<Exception>? _onError;
+        readonly Action? _onCompleted;
 
         public DelegatingObserver(Action<T> onNext,
-                                  Action<Exception> onError = null,
-                                  Action onCompleted = null)
+                                  Action<Exception>? onError = null,
+                                  Action? onCompleted = null)
         {
             _onNext = onNext ?? throw new ArgumentNullException(nameof(onNext));
             _onError = onError;

MoreLinq/DistinctBy.cs

@@ -63,7 +63,7 @@ public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TS
         /// comparing them by the specified key projection.</returns>
 
         public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source,
-            Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
+            Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
         {
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (keySelector == null) throw new ArgumentNullException(nameof(keySelector));

MoreLinq/EmptyArray.cs

@@ -0,0 +1,7 @@
+namespace MoreLinq
+{
+    static class EmptyArray<T>
+    {
+        public static readonly T[] Value = new T[0];
+    }
+}

MoreLinq/EndsWith.cs

@@ -66,7 +66,7 @@ public static bool EndsWith<T>(this IEnumerable<T> first, IEnumerable<T> second)
         /// elements at the same index.
         /// </remarks>
 
-        public static bool EndsWith<T>(this IEnumerable<T> first, IEnumerable<T> second, IEqualityComparer<T> comparer)
+        public static bool EndsWith<T>(this IEnumerable<T> first, IEnumerable<T> second, IEqualityComparer<T>? comparer)
         {
             if (first == null) throw new ArgumentNullException(nameof(first));
             if (second == null) throw new ArgumentNullException(nameof(second));

MoreLinq/EquiZip.cs

@@ -19,7 +19,6 @@ namespace MoreLinq
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics;
     using System.Linq;
 
     static partial class MoreEnumerable
@@ -169,15 +168,12 @@ public static IEnumerable<TResult> EquiZip<T1, T2, T3, T4, TResult>(
         }
 
         static IEnumerable<TResult> EquiZipImpl<T1, T2, T3, T4, TResult>(
-            IEnumerable<T1> s1,
-            IEnumerable<T2> s2,
-            IEnumerable<T3> s3,
-            IEnumerable<T4> s4,
+            IEnumerable<T1>  s1,
+            IEnumerable<T2>  s2,
+            IEnumerable<T3>? s3,
+            IEnumerable<T4>? s4,
             Func<T1, T2, T3, T4, TResult> resultSelector)
         {
-            Debug.Assert(s1 != null);
-            Debug.Assert(s2 != null);
-
             const int zero = 0, one = 1;
 
             var limit = 1 + (s3 != null ? one : zero)

MoreLinq/ExceptBy.cs

@@ -73,7 +73,7 @@ public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSou
         public static IEnumerable<TSource> ExceptBy<TSource, TKey>(this IEnumerable<TSource> first,
             IEnumerable<TSource> second,
             Func<TSource, TKey> keySelector,
-            IEqualityComparer<TKey> keyComparer)
+            IEqualityComparer<TKey>? keyComparer)
         {
             if (first == null) throw new ArgumentNullException(nameof(first));
             if (second == null) throw new ArgumentNullException(nameof(second));