List-like union as struct to save allocation + virtual dispatch

MoreLinq/AggregateRight.cs

@@ -123,7 +123,7 @@ public static TResult AggregateRight<TSource, TAccumulate, TResult>(this IEnumer
             return resultSelector(source.AggregateRight(seed, func));
         }
 
-        static TResult AggregateRightImpl<TSource, TResult>(IListLike<TSource> list, TResult accumulator, Func<TSource, TResult, TResult> func, int i)
+        static TResult AggregateRightImpl<TSource, TResult>(ListLike<TSource> list, TResult accumulator, Func<TSource, TResult, TResult> func, int i)
         {
             while (i-- > 0)
             {

MoreLinq/CountDown.cs

@@ -63,7 +63,7 @@ public static IEnumerable<TResult> CountDown<T, TResult>(this IEnumerable<T> sou
                      ? IterateCollection(collectionCount)
                      : IterateSequence();
 
-            IEnumerable<TResult> IterateList(IListLike<T> list)
+            IEnumerable<TResult> IterateList(ListLike<T> list)
             {
                 var countdown = Math.Min(count, list.Count);
 

MoreLinq/ListLike.cs

@@ -22,43 +22,51 @@ namespace MoreLinq
     using System.Linq;
 
     /// <summary>
-    /// Represents an list-like (indexable) data structure.
+    /// Represents a union over list types implementing either
+    /// <see cref="IList{T}"/> or <see cref="IReadOnlyList{T}"/>, allowing
+    /// both to be treated the same.
     /// </summary>
 
-    interface IListLike<out T>
+    readonly struct ListLike<T>
     {
-        int Count { get; }
-        T this[int index] { get; }
+        readonly IList<T>? _rw;
+        readonly IReadOnlyList<T>? _rx;
+
+        public ListLike(IList<T> list)
+        {
+            _rw = list ?? throw new ArgumentNullException(nameof(list));
+            _rx = null;
+        }
+
+        public ListLike(IReadOnlyList<T> list)
+        {
+            _rw = null;
+            _rx = list ?? throw new ArgumentNullException(nameof(list));
+        }
+
+        public int Count => _rw?.Count ?? _rx?.Count ?? 0;
+
+        public T this[int index] => _rw is { } rw ? rw[index]
+                                  : _rx is { } rx ? rx[index]
+                                  : throw new ArgumentOutOfRangeException(nameof(index));
     }
 
     static class ListLike
     {
-        public static IListLike<T> ToListLike<T>(this IEnumerable<T> source)
-            => source.TryAsListLike() ?? new List<T>(source.ToList());
+        public static ListLike<T> AsListLike<T>(this List<T> list) => new((IList<T>)list);
+        public static ListLike<T> AsListLike<T>(this IList<T> list) => new(list);
+        public static ListLike<T> AsListLike<T>(this IReadOnlyList<T> list) => new(list);
 
-        public static IListLike<T>? TryAsListLike<T>(this IEnumerable<T> source) =>
+        public static ListLike<T> ToListLike<T>(this IEnumerable<T> source)
+            => source.TryAsListLike() ?? source.ToList().AsListLike();
+
+        public static ListLike<T>? TryAsListLike<T>(this IEnumerable<T> source) =>
             source switch
             {
                 null => throw new ArgumentNullException(nameof(source)),
-                IList<T> list => new List<T>(list),
-                IReadOnlyList<T> list => new ReadOnlyList<T>(list),
+                IList<T> list => list.AsListLike(),
+                IReadOnlyList<T> list => list.AsListLike(),
                 _ => null
             };
-
-        sealed class List<T> : IListLike<T>
-        {
-            readonly IList<T> _list;
-            public List(IList<T> list) => _list = list ?? throw new ArgumentNullException(nameof(list));
-            public int Count => _list.Count;
-            public T this[int index] => _list[index];
-        }
-
-        sealed class ReadOnlyList<T> : IListLike<T>
-        {
-            readonly IReadOnlyList<T> _list;
-            public ReadOnlyList(IReadOnlyList<T> list) => _list = list ?? throw new ArgumentNullException(nameof(list));
-            public int Count => _list.Count;
-            public T this[int index] => _list[index];
-        }
     }
 }

MoreLinq/ScanRight.cs

@@ -84,7 +84,7 @@ public static IEnumerable<TAccumulate> ScanRight<TSource, TAccumulate>(this IEnu
             return ScanRightImpl(source, func, list => (seed, list.Count));
         }
 
-        static IEnumerable<TResult> ScanRightImpl<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult, TResult> func, Func<IListLike<TSource>, (TResult Seed, int Count)?> seeder)
+        static IEnumerable<TResult> ScanRightImpl<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult, TResult> func, Func<ListLike<TSource>, (TResult Seed, int Count)?> seeder)
         {
             var list = source.ToListLike();