From c86950a2be236fdc497976882c9c4fc80b957a9b Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Sat, 24 Feb 2024 20:34:09 -0500
Subject: [PATCH 1/7] Make Grouped{Result}Enumerable derive from Iterator

---
 .../src/System/Linq/Grouping.SpeedOpt.cs      |  71 ++--
 .../System.Linq/src/System/Linq/Grouping.cs   | 320 +++++++++++++-----
 .../System.Linq/src/System/Linq/Lookup.cs     |   2 +-
 3 files changed, 264 insertions(+), 129 deletions(-)

diff --git a/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
index 0a1d57df361bda..94a24fa8c112b6 100644
--- a/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
@@ -5,51 +5,54 @@
 
 namespace System.Linq
 {
-    internal sealed partial class GroupedResultEnumerable<TSource, TKey, TElement, TResult> : IIListProvider<TResult>
+    public static partial class Enumerable
     {
-        public TResult[] ToArray() =>
-            Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray(_resultSelector);
+        internal sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult> : IIListProvider<TResult>
+        {
+            public TResult[] ToArray() =>
+                Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray(_resultSelector);
 
-        public List<TResult> ToList() =>
-            Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToList(_resultSelector);
+            public List<TResult> ToList() =>
+                Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToList(_resultSelector);
 
-        public int GetCount(bool onlyIfCheap) =>
-            onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
-    }
+            public int GetCount(bool onlyIfCheap) =>
+                onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
+        }
 
-    internal sealed partial class GroupedResultEnumerable<TSource, TKey, TResult> : IIListProvider<TResult>
-    {
-        public TResult[] ToArray() =>
-            Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray(_resultSelector);
+        internal sealed partial class GroupByResultIterator<TSource, TKey, TResult> : IIListProvider<TResult>
+        {
+            public TResult[] ToArray() =>
+                Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray(_resultSelector);
 
-        public List<TResult> ToList() =>
-            Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToList(_resultSelector);
+            public List<TResult> ToList() =>
+                Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToList(_resultSelector);
 
-        public int GetCount(bool onlyIfCheap) =>
-            onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
-    }
+            public int GetCount(bool onlyIfCheap) =>
+                onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
+        }
 
-    internal sealed partial class GroupedEnumerable<TSource, TKey, TElement> : IIListProvider<IGrouping<TKey, TElement>>
-    {
-        public IGrouping<TKey, TElement>[] ToArray() =>
-            Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray();
+        internal sealed partial class GroupByIterator<TSource, TKey, TElement> : IIListProvider<IGrouping<TKey, TElement>>
+        {
+            public IGrouping<TKey, TElement>[] ToArray() =>
+                Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray();
 
-        public List<IGrouping<TKey, TElement>> ToList() =>
-            Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToList();
+            public List<IGrouping<TKey, TElement>> ToList() =>
+                Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToList();
 
-        public int GetCount(bool onlyIfCheap) =>
-            onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
-    }
+            public int GetCount(bool onlyIfCheap) =>
+                onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
+        }
 
-    internal sealed partial class GroupedEnumerable<TSource, TKey> : IIListProvider<IGrouping<TKey, TSource>>
-    {
-        public IGrouping<TKey, TSource>[] ToArray() =>
-            Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray();
+        internal sealed partial class GroupByIterator<TSource, TKey> : IIListProvider<IGrouping<TKey, TSource>>
+        {
+            public IGrouping<TKey, TSource>[] ToArray() =>
+                Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray();
 
-        public List<IGrouping<TKey, TSource>> ToList() =>
-            Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToList();
+            public List<IGrouping<TKey, TSource>> ToList() =>
+                Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToList();
 
-        public int GetCount(bool onlyIfCheap) =>
-            onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
+            public int GetCount(bool onlyIfCheap) =>
+                onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
+        }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Grouping.cs b/src/libraries/System.Linq/src/System/Linq/Grouping.cs
index f0517c953ebca3..c9b55b85cfad89 100644
--- a/src/libraries/System.Linq/src/System/Linq/Grouping.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Grouping.cs
@@ -29,7 +29,7 @@ public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this
                 return [];
             }
 
-            return new GroupedEnumerable<TSource, TKey>(source, keySelector, comparer);
+            return new GroupByIterator<TSource, TKey>(source, keySelector, comparer);
         }
 
         public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) =>
@@ -57,7 +57,7 @@ public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TEle
                 return [];
             }
 
-            return new GroupedEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
+            return new GroupByIterator<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
         }
 
         public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector) =>
@@ -85,7 +85,7 @@ public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumera
                 return [];
             }
 
-            return new GroupedResultEnumerable<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
+            return new GroupByResultIterator<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
         }
 
         public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector) =>
@@ -118,7 +118,229 @@ public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(thi
                 return [];
             }
 
-            return new GroupedResultEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
+            return new GroupByResultIterator<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
+        }
+
+        internal sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult> : Iterator<TResult>
+        {
+            private readonly IEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly Func<TSource, TElement> _elementSelector;
+            private readonly IEqualityComparer<TKey>? _comparer;
+            private readonly Func<TKey, IEnumerable<TElement>, TResult> _resultSelector;
+
+            private Lookup<TKey, TElement>? _lookup;
+            private Grouping<TKey, TElement>? _g;
+
+            public GroupByResultIterator(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey>? comparer)
+            {
+                _source = source;
+                _keySelector = keySelector;
+                _elementSelector = elementSelector;
+                _comparer = comparer;
+                _resultSelector = resultSelector;
+            }
+
+            public override Iterator<TResult> Clone() => new GroupByResultIterator<TSource, TKey, TElement, TResult>(_source, _keySelector, _elementSelector, _resultSelector, _comparer);
+
+            public override bool MoveNext()
+            {
+                switch (_state)
+                {
+                    case 1:
+                        _lookup = Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer);
+                        _g = _lookup._lastGrouping;
+                        if (_g is not null)
+                        {
+                            _state = 2;
+                            goto ValidItem;
+                        }
+                        break;
+
+                    case 2:
+                        Debug.Assert(_g is not null);
+                        Debug.Assert(_lookup is not null);
+                        if (_g != _lookup._lastGrouping)
+                        {
+                            goto ValidItem;
+                        }
+                        break;
+                }
+
+                Dispose();
+                return false;
+
+            ValidItem:
+                _g = _g._next;
+                Debug.Assert(_g is not null);
+                _g.Trim();
+                _current = _resultSelector(_g.Key, _g._elements);
+                return true;
+            }
+        }
+
+        internal sealed partial class GroupByResultIterator<TSource, TKey, TResult> : Iterator<TResult>
+        {
+            private readonly IEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly IEqualityComparer<TKey>? _comparer;
+            private readonly Func<TKey, IEnumerable<TSource>, TResult> _resultSelector;
+
+            private Lookup<TKey, TSource>? _lookup;
+            private Grouping<TKey, TSource>? _g;
+
+            public GroupByResultIterator(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey>? comparer)
+            {
+                _source = source;
+                _keySelector = keySelector;
+                _resultSelector = resultSelector;
+                _comparer = comparer;
+            }
+
+            public override Iterator<TResult> Clone() => new GroupByResultIterator<TSource, TKey, TResult>(_source, _keySelector, _resultSelector, _comparer);
+
+            public override bool MoveNext()
+            {
+                switch (_state)
+                {
+                    case 1:
+                        _lookup = Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer);
+                        _g = _lookup._lastGrouping;
+                        if (_g is not null)
+                        {
+                            _state = 2;
+                            goto ValidItem;
+                        }
+                        break;
+
+                    case 2:
+                        Debug.Assert(_g is not null);
+                        Debug.Assert(_lookup is not null);
+                        if (_g != _lookup._lastGrouping)
+                        {
+                            goto ValidItem;
+                        }
+                        break;
+                }
+
+                Dispose();
+                return false;
+
+            ValidItem:
+                _g = _g._next;
+                Debug.Assert(_g is not null);
+                _g.Trim();
+                _current = _resultSelector(_g.Key, _g._elements);
+                return true;
+            }
+        }
+
+        internal sealed partial class GroupByIterator<TSource, TKey, TElement> : Iterator<IGrouping<TKey, TElement>>
+        {
+            private readonly IEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly Func<TSource, TElement> _elementSelector;
+            private readonly IEqualityComparer<TKey>? _comparer;
+
+            private Lookup<TKey, TElement>? _lookup;
+            private Grouping<TKey, TElement>? _g;
+
+            public GroupByIterator(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer)
+            {
+                _source = source;
+                _keySelector = keySelector;
+                _elementSelector = elementSelector;
+                _comparer = comparer;
+            }
+
+            public override Iterator<IGrouping<TKey, TElement>> Clone() => new GroupByIterator<TSource, TKey, TElement>(_source, _keySelector, _elementSelector, _comparer);
+
+            public override bool MoveNext()
+            {
+                switch (_state)
+                {
+                    case 1:
+                        _lookup = Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer);
+                        _g = _lookup._lastGrouping;
+                        if (_g is not null)
+                        {
+                            _state = 2;
+                            goto ValidItem;
+                        }
+                        break;
+
+                    case 2:
+                        Debug.Assert(_g is not null);
+                        Debug.Assert(_lookup is not null);
+                        if (_g != _lookup._lastGrouping)
+                        {
+                            goto ValidItem;
+                        }
+                        break;
+                }
+
+                Dispose();
+                return false;
+
+            ValidItem:
+                _g = _g._next;
+                Debug.Assert(_g is not null);
+                _current = _g;
+                return true;
+            }
+        }
+
+        internal sealed partial class GroupByIterator<TSource, TKey> : Iterator<IGrouping<TKey, TSource>>
+        {
+            private readonly IEnumerable<TSource> _source;
+            private readonly Func<TSource, TKey> _keySelector;
+            private readonly IEqualityComparer<TKey>? _comparer;
+
+            private Lookup<TKey, TSource>? _lookup;
+            private Grouping<TKey, TSource>? _g;
+
+            public GroupByIterator(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
+            {
+                _source = source;
+                _keySelector = keySelector;
+                _comparer = comparer;
+            }
+
+            public override Iterator<IGrouping<TKey, TSource>> Clone() => new GroupByIterator<TSource, TKey>(_source, _keySelector, _comparer);
+
+            public override bool MoveNext()
+            {
+                switch (_state)
+                {
+                    case 1:
+                        _lookup = Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer);
+                        _g = _lookup._lastGrouping;
+                        if (_g is not null)
+                        {
+                            _state = 2;
+                            goto ValidItem;
+                        }
+                        break;
+
+                    case 2:
+                        Debug.Assert(_g is not null);
+                        Debug.Assert(_lookup is not null);
+                        if (_g != _lookup._lastGrouping)
+                        {
+                            goto ValidItem;
+                        }
+                        break;
+                }
+
+                Dispose();
+                return false;
+
+                ValidItem:
+                _g = _g._next;
+                Debug.Assert(_g is not null);
+                _current = _g;
+                return true;
+            }
         }
     }
 
@@ -219,94 +441,4 @@ TElement IList<TElement>.this[int index]
             }
         }
     }
-
-    internal sealed partial class GroupedResultEnumerable<TSource, TKey, TElement, TResult> : IEnumerable<TResult>
-    {
-        private readonly IEnumerable<TSource> _source;
-        private readonly Func<TSource, TKey> _keySelector;
-        private readonly Func<TSource, TElement> _elementSelector;
-        private readonly IEqualityComparer<TKey>? _comparer;
-        private readonly Func<TKey, IEnumerable<TElement>, TResult> _resultSelector;
-
-        public GroupedResultEnumerable(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey>? comparer)
-        {
-            _source = source;
-            _keySelector = keySelector;
-            _elementSelector = elementSelector;
-            _comparer = comparer;
-            _resultSelector = resultSelector;
-        }
-
-        public IEnumerator<TResult> GetEnumerator()
-        {
-            Lookup<TKey, TElement> lookup = Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer);
-            return lookup.ApplyResultSelector(_resultSelector).GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-    }
-
-    internal sealed partial class GroupedResultEnumerable<TSource, TKey, TResult> : IEnumerable<TResult>
-    {
-        private readonly IEnumerable<TSource> _source;
-        private readonly Func<TSource, TKey> _keySelector;
-        private readonly IEqualityComparer<TKey>? _comparer;
-        private readonly Func<TKey, IEnumerable<TSource>, TResult> _resultSelector;
-
-        public GroupedResultEnumerable(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey>? comparer)
-        {
-            _source = source;
-            _keySelector = keySelector;
-            _resultSelector = resultSelector;
-            _comparer = comparer;
-        }
-
-        public IEnumerator<TResult> GetEnumerator()
-        {
-            Lookup<TKey, TSource> lookup = Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer);
-            return lookup.ApplyResultSelector(_resultSelector).GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-    }
-
-    internal sealed partial class GroupedEnumerable<TSource, TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>
-    {
-        private readonly IEnumerable<TSource> _source;
-        private readonly Func<TSource, TKey> _keySelector;
-        private readonly Func<TSource, TElement> _elementSelector;
-        private readonly IEqualityComparer<TKey>? _comparer;
-
-        public GroupedEnumerable(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer)
-        {
-            _source = source;
-            _keySelector = keySelector;
-            _elementSelector = elementSelector;
-            _comparer = comparer;
-        }
-
-        public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator() =>
-            Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-    }
-
-    internal sealed partial class GroupedEnumerable<TSource, TKey> : IEnumerable<IGrouping<TKey, TSource>>
-    {
-        private readonly IEnumerable<TSource> _source;
-        private readonly Func<TSource, TKey> _keySelector;
-        private readonly IEqualityComparer<TKey>? _comparer;
-
-        public GroupedEnumerable(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey>? comparer)
-        {
-            _source = source;
-            _keySelector = keySelector;
-            _comparer = comparer;
-        }
-
-        public IEnumerator<IGrouping<TKey, TSource>> GetEnumerator() =>
-            Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).GetEnumerator();
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-    }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Lookup.cs b/src/libraries/System.Linq/src/System/Linq/Lookup.cs
index 7aca5c732e72d1..2b7fbb20b8594f 100644
--- a/src/libraries/System.Linq/src/System/Linq/Lookup.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Lookup.cs
@@ -76,7 +76,7 @@ public partial class Lookup<TKey, TElement> : ILookup<TKey, TElement>
     {
         private readonly IEqualityComparer<TKey> _comparer;
         private Grouping<TKey, TElement>[] _groupings;
-        private protected Grouping<TKey, TElement>? _lastGrouping;
+        internal Grouping<TKey, TElement>? _lastGrouping;
         private int _count;
 
         internal static Lookup<TKey, TElement> Create<TSource>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey>? comparer)

From b5d64297d86cace30216b816e44a163738368d03 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Sun, 25 Feb 2024 21:29:13 -0500
Subject: [PATCH 2/7] Make OrderedPartition derive from Iterator

---
 .../System/Linq/OrderedEnumerable.SpeedOpt.cs | 108 ++++++++++++++++++
 .../src/System/Linq/OrderedEnumerable.cs      |  33 +-----
 .../src/System/Linq/Partition.SpeedOpt.cs     |  59 ----------
 3 files changed, 110 insertions(+), 90 deletions(-)

diff --git a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs
index 6dfde9efd62301..a666f9f1df5748 100644
--- a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs
@@ -434,5 +434,113 @@ public override List<TElement> ToList()
                 return default;
             }
         }
+
+        internal sealed class OrderedPartition<TElement> : Iterator<TElement>, IPartition<TElement>
+        {
+            private readonly OrderedEnumerable<TElement> _source;
+            private readonly int _minIndexInclusive;
+            private readonly int _maxIndexInclusive;
+
+            private TElement[]? _buffer;
+            private int[]? _map;
+            private int _maxIdx;
+
+            public OrderedPartition(OrderedEnumerable<TElement> source, int minIdxInclusive, int maxIdxInclusive)
+            {
+                _source = source;
+                _minIndexInclusive = minIdxInclusive;
+                _maxIndexInclusive = maxIdxInclusive;
+            }
+
+            public override Iterator<TElement> Clone() => new OrderedPartition<TElement>(_source, _minIndexInclusive, _maxIndexInclusive);
+
+            public override bool MoveNext()
+            {
+                int state = _state;
+
+            Initialized:
+                if (state > 1)
+                {
+                    Debug.Assert(_buffer is not null);
+                    Debug.Assert(_map is not null);
+
+                    int[] map = _map;
+                    int i = state - 2 + _minIndexInclusive;
+                    if (i <= _maxIdx)
+                    {
+                        _current = _buffer[map[i]];
+                        _state++;
+                        return true;
+                    }
+                }
+                else if (state == 1)
+                {
+                    TElement[] buffer = _source.ToArray();
+                    int count = buffer.Length;
+                    if (count > _minIndexInclusive)
+                    {
+                        _maxIdx = _maxIndexInclusive;
+                        if (count <= _maxIdx)
+                        {
+                            _maxIdx = count - 1;
+                        }
+
+                        if (_minIndexInclusive == _maxIdx)
+                        {
+                            _current = _source.GetEnumerableSorter().ElementAt(buffer, count, _minIndexInclusive);
+                            _state = -1;
+                            return true;
+                        }
+
+                        _map = _source.SortedMap(buffer, _minIndexInclusive, _maxIdx);
+                        _buffer = buffer;
+                        _state = state = 2;
+                        goto Initialized;
+                    }
+                }
+
+                Dispose();
+                return false;
+            }
+
+            public IPartition<TElement>? Skip(int count)
+            {
+                int minIndex = _minIndexInclusive + count;
+                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new OrderedPartition<TElement>(_source, minIndex, _maxIndexInclusive);
+            }
+
+            public IPartition<TElement> Take(int count)
+            {
+                int maxIndex = _minIndexInclusive + count - 1;
+                if ((uint)maxIndex >= (uint)_maxIndexInclusive)
+                {
+                    return this;
+                }
+
+                return new OrderedPartition<TElement>(_source, _minIndexInclusive, maxIndex);
+            }
+
+            public TElement? TryGetElementAt(int index, out bool found)
+            {
+                if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive))
+                {
+                    return _source.TryGetElementAt(index + _minIndexInclusive, out found);
+                }
+
+                found = false;
+                return default;
+            }
+
+            public TElement? TryGetFirst(out bool found) => _source.TryGetElementAt(_minIndexInclusive, out found);
+
+            public TElement? TryGetLast(out bool found) =>
+                _source.TryGetLast(_minIndexInclusive, _maxIndexInclusive, out found);
+
+            public TElement[] ToArray() => _source.ToArray(_minIndexInclusive, _maxIndexInclusive);
+
+            public List<TElement> ToList() => _source.ToList(_minIndexInclusive, _maxIndexInclusive);
+
+            public int GetCount(bool onlyIfCheap) => _source.GetCount(_minIndexInclusive, _maxIndexInclusive, onlyIfCheap);
+        }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
index 1e888c974b3ada..b87f4fbc3dadc5 100644
--- a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
+++ b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
@@ -17,39 +17,10 @@ internal abstract partial class OrderedEnumerable<TElement> : Iterator<TElement>
 
             private protected int[] SortedMap(TElement[] buffer) => GetEnumerableSorter().Sort(buffer, buffer.Length);
 
-            private int[] SortedMap(TElement[] buffer, int minIdx, int maxIdx) =>
+            internal int[] SortedMap(TElement[] buffer, int minIdx, int maxIdx) =>
                 GetEnumerableSorter().Sort(buffer, buffer.Length, minIdx, maxIdx);
 
-            internal IEnumerator<TElement> GetEnumerator(int minIdx, int maxIdx)
-            {
-                TElement[] buffer = _source.ToArray();
-                int count = buffer.Length;
-                if (count > minIdx)
-                {
-                    if (count <= maxIdx)
-                    {
-                        maxIdx = count - 1;
-                    }
-
-                    if (minIdx == maxIdx)
-                    {
-                        yield return GetEnumerableSorter().ElementAt(buffer, count, minIdx);
-                    }
-                    else
-                    {
-                        int[] map = SortedMap(buffer, minIdx, maxIdx);
-                        while (minIdx <= maxIdx)
-                        {
-                            yield return buffer[map[minIdx]];
-                            ++minIdx;
-                        }
-                    }
-                }
-            }
-
-            private EnumerableSorter<TElement> GetEnumerableSorter() => GetEnumerableSorter(null);
-
-            internal abstract EnumerableSorter<TElement> GetEnumerableSorter(EnumerableSorter<TElement>? next);
+            internal abstract EnumerableSorter<TElement> GetEnumerableSorter(EnumerableSorter<TElement>? next = null);
 
             internal abstract CachingComparer<TElement> GetComparer(CachingComparer<TElement>? childComparer = null);
 
diff --git a/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
index d7b04eb82b917e..b8e3d32c282747 100644
--- a/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 
@@ -9,64 +8,6 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        internal sealed class OrderedPartition<TElement> : IPartition<TElement>
-        {
-            private readonly OrderedEnumerable<TElement> _source;
-            private readonly int _minIndexInclusive;
-            private readonly int _maxIndexInclusive;
-
-            public OrderedPartition(OrderedEnumerable<TElement> source, int minIdxInclusive, int maxIdxInclusive)
-            {
-                _source = source;
-                _minIndexInclusive = minIdxInclusive;
-                _maxIndexInclusive = maxIdxInclusive;
-            }
-
-            public IEnumerator<TElement> GetEnumerator() => _source.GetEnumerator(_minIndexInclusive, _maxIndexInclusive);
-
-            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
-            public IPartition<TElement>? Skip(int count)
-            {
-                int minIndex = _minIndexInclusive + count;
-                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new OrderedPartition<TElement>(_source, minIndex, _maxIndexInclusive);
-            }
-
-            public IPartition<TElement> Take(int count)
-            {
-                int maxIndex = _minIndexInclusive + count - 1;
-                if ((uint)maxIndex >= (uint)_maxIndexInclusive)
-                {
-                    return this;
-                }
-
-                return new OrderedPartition<TElement>(_source, _minIndexInclusive, maxIndex);
-            }
-
-            public TElement? TryGetElementAt(int index, out bool found)
-            {
-                if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive))
-                {
-                    return _source.TryGetElementAt(index + _minIndexInclusive, out found);
-                }
-
-                found = false;
-                return default;
-            }
-
-            public TElement? TryGetFirst(out bool found) => _source.TryGetElementAt(_minIndexInclusive, out found);
-
-            public TElement? TryGetLast(out bool found) =>
-                _source.TryGetLast(_minIndexInclusive, _maxIndexInclusive, out found);
-
-            public TElement[] ToArray() => _source.ToArray(_minIndexInclusive, _maxIndexInclusive);
-
-            public List<TElement> ToList() => _source.ToList(_minIndexInclusive, _maxIndexInclusive);
-
-            public int GetCount(bool onlyIfCheap) => _source.GetCount(_minIndexInclusive, _maxIndexInclusive, onlyIfCheap);
-        }
-
-
         /// <summary>
         /// An iterator that yields the items of part of an <see cref="IList{TSource}"/>.
         /// </summary>

From 51b3adcd002875618a39ab277f5ce7aa63fdaf52 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Mon, 26 Feb 2024 13:09:19 -0500
Subject: [PATCH 3/7] Consolidate LINQ's internal IIListProvider/IPartition
 into base Iterator

LINQ has an internal base Iterator class that's used when operators manually implement enumeration rather than having the compiler implement it with an iterator. That base class includes several abstract/virtual methods, including a Select and Where virtual method that have been present since the beginning of LINQ: those are used in a case of A().B(), where B is Select or Where and where A can then improve the processing of B by returning a customized implementation aware of some aspect of both A and B (e.g. the enumerable returned from .Where().Select() includes both the where and select functionality in that single object). Over the years, other specialization has been added to LINQ, in the form of additional internal interfaces: IIListProvider and IPartition. These interfaces similarly enable optimizing sequences A().B(), where B is other LINQ methods, e.g. IIListProvider enables optimizing ToArray/ToList/Count, and IPartition enables optimizing Skip/Take/First/Last/ElementAt. There was a complicated venn diagram of which types implemented which interfaces and base type.

This PR merges IIListProvider/IPartition into the base Iterator class. Everything from IPartition is virtual, enabling derivations to specialize just a subset of the functionality, and deduplicating some implementations that were providing the same implementation instead of having it shared in a base. Code that was type testing for the interfaces now type tests for the base class, which means we can delete some type testing where both the interfaces and the base class were previously being tested for.  We no longer have this strange split across multiple optimization-focused internal implementation details, and instead have everything consolidated in the one base class. This also means that all of the calls that were previously interface dispatch are now virtual dispatch.
---
 .../System.Linq/src/System.Linq.csproj        |   4 +-
 .../src/System/Linq/AppendPrepend.SpeedOpt.cs |  66 ++++-
 .../src/System/Linq/Cast.SpeedOpt.cs          |  21 +-
 .../src/System/Linq/Concat.SpeedOpt.cs        |  18 +-
 .../System.Linq/src/System/Linq/Count.cs      |  12 +-
 .../System/Linq/DefaultIfEmpty.SpeedOpt.cs    |  50 +++-
 .../src/System/Linq/Distinct.SpeedOpt.cs      |  10 +-
 .../System.Linq/src/System/Linq/ElementAt.cs  |  72 +++--
 .../System.Linq/src/System/Linq/First.cs      |  14 +-
 .../src/System/Linq/Grouping.SpeedOpt.cs      |  32 +--
 .../src/System/Linq/IIListProvider.cs         |  33 ---
 .../System.Linq/src/System/Linq/IPartition.cs |  47 ----
 .../src/System/Linq/Iterator.SpeedOpt.cs      |  71 +++++
 .../System.Linq/src/System/Linq/Iterator.cs   |  31 +--
 .../System.Linq/src/System/Linq/Last.cs       |  14 +-
 .../System.Linq/src/System/Linq/OrderBy.cs    |  12 +-
 .../System/Linq/OrderedEnumerable.SpeedOpt.cs |  56 ++--
 .../src/System/Linq/OrderedEnumerable.cs      |  20 +-
 .../src/System/Linq/Partition.SpeedOpt.cs     |  97 ++++---
 .../src/System/Linq/Range.SpeedOpt.cs         |  20 +-
 .../src/System/Linq/Repeat.SpeedOpt.cs        |  21 +-
 .../src/System/Linq/Reverse.SpeedOpt.cs       |  26 +-
 .../src/System/Linq/Select.SpeedOpt.cs        | 245 +++++++++++-------
 .../System.Linq/src/System/Linq/Select.cs     |  55 ++--
 .../src/System/Linq/SelectMany.SpeedOpt.cs    |   8 +-
 .../src/System/Linq/Skip.SpeedOpt.cs          |   4 +-
 .../System.Linq/src/System/Linq/Skip.cs       |   8 +-
 .../src/System/Linq/Take.SpeedOpt.cs          |  18 +-
 .../src/System/Linq/ToCollection.cs           |  12 +-
 .../src/System/Linq/Union.SpeedOpt.cs         |  24 +-
 .../src/System/Linq/Where.SpeedOpt.cs         | 108 +++-----
 .../System.Linq/src/System/Linq/Where.cs      |  60 ++---
 .../System.Linq/tests/AppendPrependTests.cs   |  22 ++
 .../System.Linq/tests/ElementAtTests.cs       |  12 +-
 34 files changed, 724 insertions(+), 599 deletions(-)
 delete mode 100644 src/libraries/System.Linq/src/System/Linq/IIListProvider.cs
 delete mode 100644 src/libraries/System.Linq/src/System/Linq/IPartition.cs
 create mode 100644 src/libraries/System.Linq/src/System/Linq/Iterator.SpeedOpt.cs

diff --git a/src/libraries/System.Linq/src/System.Linq.csproj b/src/libraries/System.Linq/src/System.Linq.csproj
index cbc128d961e880..c9bcf4ac0470a8 100644
--- a/src/libraries/System.Linq/src/System.Linq.csproj
+++ b/src/libraries/System.Linq/src/System.Linq.csproj
@@ -9,6 +9,7 @@
   <PropertyGroup>
     <TargetPlatformIdentifier>$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)'))</TargetPlatformIdentifier>
     <OptimizeForSize Condition="'$(TargetPlatformIdentifier)' == 'browser' or '$(TargetPlatformIdentifier)' == 'android' or '$(TargetPlatformIdentifier)' == 'ios' or '$(TargetPlatformIdentifier)' == 'tvos'">true</OptimizeForSize>
+    <DefineConstants Condition="'$(OptimizeForSize)' == 'true'">$(DefineConstants);OPTIMIZE_FOR_SIZE</DefineConstants>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(OptimizeForSize)' == true">
@@ -23,6 +24,7 @@
     <Compile Include="System\Linq\DefaultIfEmpty.SpeedOpt.cs" />
     <Compile Include="System\Linq\Distinct.SpeedOpt.cs" />
     <Compile Include="System\Linq\Grouping.SpeedOpt.cs" />
+    <Compile Include="System\Linq\Iterator.SpeedOpt.cs" />
     <Compile Include="System\Linq\Lookup.SpeedOpt.cs" />
     <Compile Include="System\Linq\OrderedEnumerable.SpeedOpt.cs" />
     <Compile Include="System\Linq\Partition.SpeedOpt.cs" />
@@ -61,8 +63,6 @@
     <Compile Include="System\Linq\Index.cs" />
     <Compile Include="System\Linq\Intersect.cs" />
     <Compile Include="System\Linq\Iterator.cs" />
-    <Compile Include="System\Linq\IIListProvider.cs" />
-    <Compile Include="System\Linq\IPartition.cs" />
     <Compile Include="System\Linq\Join.cs" />
     <Compile Include="System\Linq\Last.cs" />
     <Compile Include="System\Linq\Lookup.cs" />
diff --git a/src/libraries/System.Linq/src/System/Linq/AppendPrepend.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/AppendPrepend.SpeedOpt.cs
index 80ee23998603fa..cfd6ea79527438 100644
--- a/src/libraries/System.Linq/src/System/Linq/AppendPrepend.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/AppendPrepend.SpeedOpt.cs
@@ -8,15 +8,6 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private abstract partial class AppendPrependIterator<TSource> : IIListProvider<TSource>
-        {
-            public abstract TSource[] ToArray();
-
-            public abstract List<TSource> ToList();
-
-            public abstract int GetCount(bool onlyIfCheap);
-        }
-
         private sealed partial class AppendPrepend1Iterator<TSource>
         {
             private TSource[] LazyToArray()
@@ -130,14 +121,63 @@ public override List<TSource> ToList()
 
             public override int GetCount(bool onlyIfCheap)
             {
-                if (_source is IIListProvider<TSource> listProv)
+                if (_source is Iterator<TSource> iterator)
                 {
-                    int count = listProv.GetCount(onlyIfCheap);
+                    int count = iterator.GetCount(onlyIfCheap);
                     return count == -1 ? -1 : count + 1;
                 }
 
                 return !onlyIfCheap || _source is ICollection<TSource> ? _source.Count() + 1 : -1;
             }
+
+            public override TSource? TryGetFirst(out bool found)
+            {
+                if (_appending)
+                {
+                    TSource? first = _source.TryGetFirst(out found);
+                    if (found)
+                    {
+                        return first;
+                    }
+                }
+
+                found = true;
+                return _item;
+            }
+
+            public override TSource? TryGetLast(out bool found)
+            {
+                if (!_appending)
+                {
+                    TSource? last = _source.TryGetLast(out found);
+                    if (found)
+                    {
+                        return last;
+                    }
+                }
+
+                found = true;
+                return _item;
+            }
+
+            public override TSource? TryGetElementAt(int index, out bool found)
+            {
+                if (!_appending)
+                {
+                    if (index == 0)
+                    {
+                        found = true;
+                        return _item;
+                    }
+
+                    index--;
+                    return
+                        _source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
+                        TryGetElementAtNonIterator(_source, index, out found);
+                }
+
+                return base.TryGetElementAt(index, out found);
+            }
         }
 
         private sealed partial class AppendPrependN<TSource>
@@ -232,9 +272,9 @@ public override List<TSource> ToList()
 
             public override int GetCount(bool onlyIfCheap)
             {
-                if (_source is IIListProvider<TSource> listProv)
+                if (_source is Iterator<TSource> iterator)
                 {
-                    int count = listProv.GetCount(onlyIfCheap);
+                    int count = iterator.GetCount(onlyIfCheap);
                     return count == -1 ? -1 : count + _appendCount + _prependCount;
                 }
 
diff --git a/src/libraries/System.Linq/src/System/Linq/Cast.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Cast.SpeedOpt.cs
index 6ab50403c9c6d9..3cded1625e8df0 100644
--- a/src/libraries/System.Linq/src/System/Linq/Cast.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Cast.SpeedOpt.cs
@@ -8,11 +8,11 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class CastICollectionIterator<TResult> : IPartition<TResult>
+        private sealed partial class CastICollectionIterator<TResult>
         {
-            public int GetCount(bool onlyIfCheap) => _source.Count;
+            public override int GetCount(bool onlyIfCheap) => _source.Count;
 
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 TResult[] array = new TResult[_source.Count];
 
@@ -25,7 +25,7 @@ public TResult[] ToArray()
                 return array;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 List<TResult> list = new(_source.Count);
 
@@ -37,7 +37,7 @@ public List<TResult> ToList()
                 return list;
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if (index >= 0)
                 {
@@ -65,7 +65,7 @@ public List<TResult> ToList()
                 return default;
             }
 
-            public TResult? TryGetFirst(out bool found)
+            public override TResult? TryGetFirst(out bool found)
             {
                 IEnumerator e = _source.GetEnumerator();
                 try
@@ -85,7 +85,7 @@ public List<TResult> ToList()
                 return default;
             }
 
-            public TResult? TryGetLast(out bool found)
+            public override TResult? TryGetLast(out bool found)
             {
                 IEnumerator e = _source.GetEnumerator();
                 try
@@ -110,13 +110,6 @@ public List<TResult> ToList()
                     (e as IDisposable)?.Dispose();
                 }
             }
-
-            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectIPartitionIterator<TResult, TResult2>(this, selector);
-
-            public IPartition<TResult>? Skip(int count) => new EnumerablePartition<TResult>(this, count, -1);
-
-            public IPartition<TResult>? Take(int count) => new EnumerablePartition<TResult>(this, 0, count - 1);
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Concat.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Concat.SpeedOpt.cs
index a5ad64f78584f6..6ee051c00c2790 100644
--- a/src/libraries/System.Linq/src/System/Linq/Concat.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Concat.SpeedOpt.cs
@@ -342,13 +342,9 @@ private TSource[] PreallocatingToArray()
             }
         }
 
-        private abstract partial class ConcatIterator<TSource> : IPartition<TSource>
+        private abstract partial class ConcatIterator<TSource>
         {
-            public abstract int GetCount(bool onlyIfCheap);
-
-            public abstract TSource[] ToArray();
-
-            public List<TSource> ToList()
+            public override List<TSource> ToList()
             {
                 int count = GetCount(onlyIfCheap: true);
                 var list = count != -1 ? new List<TSource>(count) : new List<TSource>();
@@ -367,16 +363,6 @@ public List<TSource> ToList()
                 return list;
             }
 
-            public abstract TSource? TryGetElementAt(int index, out bool found);
-
-            public abstract TSource? TryGetFirst(out bool found);
-
-            public abstract TSource? TryGetLast(out bool found);
-
-            public IPartition<TSource>? Skip(int count) => new EnumerablePartition<TSource>(this, count, -1);
-
-            public IPartition<TSource>? Take(int count) => new EnumerablePartition<TSource>(this, 0, count - 1);
-
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Count.cs b/src/libraries/System.Linq/src/System/Linq/Count.cs
index 14f3d457f6ea35..048ebc0891e76c 100644
--- a/src/libraries/System.Linq/src/System/Linq/Count.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Count.cs
@@ -20,10 +20,12 @@ public static int Count<TSource>(this IEnumerable<TSource> source)
                 return collectionoft.Count;
             }
 
-            if (source is IIListProvider<TSource> listProv)
+#if !OPTIMIZE_FOR_SIZE
+            if (source is Iterator<TSource> iterator)
             {
-                return listProv.GetCount(onlyIfCheap: false);
+                return iterator.GetCount(onlyIfCheap: false);
             }
+#endif
 
             if (source is ICollection collection)
             {
@@ -105,15 +107,17 @@ public static bool TryGetNonEnumeratedCount<TSource>(this IEnumerable<TSource> s
                 return true;
             }
 
-            if (source is IIListProvider<TSource> listProv)
+#if !OPTIMIZE_FOR_SIZE
+            if (source is Iterator<TSource> iterator)
             {
-                int c = listProv.GetCount(onlyIfCheap: true);
+                int c = iterator.GetCount(onlyIfCheap: true);
                 if (c >= 0)
                 {
                     count = c;
                     return true;
                 }
             }
+#endif
 
             if (source is ICollection collection)
             {
diff --git a/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs
index 24619cc438136b..e147870eb0d9f7 100644
--- a/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs
@@ -8,15 +8,15 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class DefaultIfEmptyIterator<TSource> : IIListProvider<TSource>
+        private sealed partial class DefaultIfEmptyIterator<TSource>
         {
-            public TSource[] ToArray()
+            public override TSource[] ToArray()
             {
                 TSource[] array = _source.ToArray();
                 return array.Length == 0 ? [_default] : array;
             }
 
-            public List<TSource> ToList()
+            public override List<TSource> ToList()
             {
                 List<TSource> list = _source.ToList();
                 if (list.Count == 0)
@@ -27,7 +27,7 @@ public List<TSource> ToList()
                 return list;
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 int count;
                 if (!onlyIfCheap || _source is ICollection<TSource> || _source is ICollection)
@@ -36,11 +36,51 @@ public int GetCount(bool onlyIfCheap)
                 }
                 else
                 {
-                    count = _source is IIListProvider<TSource> listProv ? listProv.GetCount(onlyIfCheap: true) : -1;
+                    count = _source is Iterator<TSource> iterator ? iterator.GetCount(onlyIfCheap: true) : -1;
                 }
 
                 return count == 0 ? 1 : count;
             }
+
+            public override TSource? TryGetFirst(out bool found)
+            {
+                TSource? first = _source.TryGetFirst(out found);
+                if (found)
+                {
+                    return first;
+                }
+
+                found = true;
+                return default;
+            }
+
+            public override TSource? TryGetLast(out bool found)
+            {
+                TSource? last = _source.TryGetLast(out found);
+                if (found)
+                {
+                    return last;
+                }
+
+                found = true;
+                return default;
+            }
+
+            public override TSource? TryGetElementAt(int index, out bool found)
+            {
+                TSource? item = _source.TryGetElementAt(index, out found);
+                if (found)
+                {
+                    return item;
+                }
+
+                if (index == 0)
+                {
+                    found = true;
+                }
+
+                return default;
+            }
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Distinct.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Distinct.SpeedOpt.cs
index 97ac750843e5bc..a3dbb6458969cf 100644
--- a/src/libraries/System.Linq/src/System/Linq/Distinct.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Distinct.SpeedOpt.cs
@@ -7,13 +7,15 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class DistinctIterator<TSource> : IIListProvider<TSource>
+        private sealed partial class DistinctIterator<TSource>
         {
-            public TSource[] ToArray() => HashSetToArray(new HashSet<TSource>(_source, _comparer));
+            public override TSource[] ToArray() => HashSetToArray(new HashSet<TSource>(_source, _comparer));
 
-            public List<TSource> ToList() => new List<TSource>(new HashSet<TSource>(_source, _comparer));
+            public override List<TSource> ToList() => new List<TSource>(new HashSet<TSource>(_source, _comparer));
 
-            public int GetCount(bool onlyIfCheap) => onlyIfCheap ? -1 : new HashSet<TSource>(_source, _comparer).Count;
+            public override int GetCount(bool onlyIfCheap) => onlyIfCheap ? -1 : new HashSet<TSource>(_source, _comparer).Count;
+
+            public override TSource? TryGetFirst(out bool found) => _source.TryGetFirst(out found);
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/ElementAt.cs b/src/libraries/System.Linq/src/System/Linq/ElementAt.cs
index b33fcaddff924a..f2bec12be649aa 100644
--- a/src/libraries/System.Linq/src/System/Linq/ElementAt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/ElementAt.cs
@@ -16,25 +16,13 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int i
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            if (source is IPartition<TSource> partition)
+            TSource? element = TryGetElementAt(source, index, out bool found);
+            if (!found)
             {
-                TSource? element = partition.TryGetElementAt(index, out bool found);
-                if (found)
-                {
-                    return element!;
-                }
-            }
-            else if (source is IList<TSource> list)
-            {
-                return list[index];
-            }
-            else if (TryGetElement(source, index, out TSource? element))
-            {
-                return element;
+                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
             }
 
-            ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
-            return default;
+            return element!;
         }
 
         /// <summary>Returns the element at a specified index in a sequence.</summary>
@@ -80,18 +68,7 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, Index
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            if (source is IPartition<TSource> partition)
-            {
-                return partition.TryGetElementAt(index, out bool _);
-            }
-
-            if (source is IList<TSource> list)
-            {
-                return (uint)index < (uint)list.Count ? list[index] : default;
-            }
-
-            TryGetElement(source, index, out TSource? element);
-            return element;
+            return TryGetElementAt(source, index, out _);
         }
 
         /// <summary>Returns the element at a specified index in a sequence or a default value if the index is out of range.</summary>
@@ -125,27 +102,44 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, Index
             return element;
         }
 
-        private static bool TryGetElement<TSource>(IEnumerable<TSource> source, int index, [MaybeNullWhen(false)] out TSource element)
+        private static TSource? TryGetElementAt<TSource>(this IEnumerable<TSource> source, int index, out bool found) =>
+#if !OPTIMIZE_FOR_SIZE
+            source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
+#endif
+            TryGetElementAtNonIterator(source, index, out found);
+
+        private static TSource? TryGetElementAtNonIterator<TSource>(IEnumerable<TSource> source, int index, out bool found)
         {
             Debug.Assert(source != null);
 
-            if (index >= 0)
+            if (source is IList<TSource> list)
             {
-                using IEnumerator<TSource> e = source.GetEnumerator();
-                while (e.MoveNext())
+                if ((uint)index < (uint)list.Count)
+                {
+                    found = true;
+                    return list[index];
+                }
+            }
+            else
+            {
+                if (index >= 0)
                 {
-                    if (index == 0)
+                    using IEnumerator<TSource> e = source.GetEnumerator();
+                    while (e.MoveNext())
                     {
-                        element = e.Current;
-                        return true;
-                    }
+                        if (index == 0)
+                        {
+                            found = true;
+                            return e.Current;
+                        }
 
-                    index--;
+                        index--;
+                    }
                 }
             }
 
-            element = default;
-            return false;
+            found = false;
+            return default;
         }
 
         private static bool TryGetElementFromEnd<TSource>(IEnumerable<TSource> source, int indexFromEnd, [MaybeNullWhen(false)] out TSource element)
diff --git a/src/libraries/System.Linq/src/System/Linq/First.cs b/src/libraries/System.Linq/src/System/Linq/First.cs
index 1c62f547d9a03c..6879be5fc3c82e 100644
--- a/src/libraries/System.Linq/src/System/Linq/First.cs
+++ b/src/libraries/System.Linq/src/System/Linq/First.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics;
 
 namespace System.Linq
 {
@@ -69,11 +69,15 @@ public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source,
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            if (source is IPartition<TSource> partition)
-            {
-                return partition.TryGetFirst(out found);
-            }
+            return
+#if !OPTIMIZE_FOR_SIZE
+                source is Iterator<TSource> iterator ? iterator.TryGetFirst(out found) :
+#endif
+                TryGetFirstNonIterator(source, out found);
+        }
 
+        private static TSource? TryGetFirstNonIterator<TSource>(IEnumerable<TSource> source, out bool found)
+        {
             if (source is IList<TSource> list)
             {
                 if (list.Count > 0)
diff --git a/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
index 94a24fa8c112b6..1153dc7ff4977a 100644
--- a/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
@@ -7,51 +7,51 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        internal sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult> : IIListProvider<TResult>
+        internal sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult>
         {
-            public TResult[] ToArray() =>
+            public override TResult[] ToArray() =>
                 Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray(_resultSelector);
 
-            public List<TResult> ToList() =>
+            public override List<TResult> ToList() =>
                 Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToList(_resultSelector);
 
-            public int GetCount(bool onlyIfCheap) =>
+            public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
         }
 
-        internal sealed partial class GroupByResultIterator<TSource, TKey, TResult> : IIListProvider<TResult>
+        internal sealed partial class GroupByResultIterator<TSource, TKey, TResult>
         {
-            public TResult[] ToArray() =>
+            public override TResult[] ToArray() =>
                 Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray(_resultSelector);
 
-            public List<TResult> ToList() =>
+            public override List<TResult> ToList() =>
                 Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToList(_resultSelector);
 
-            public int GetCount(bool onlyIfCheap) =>
+            public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
         }
 
-        internal sealed partial class GroupByIterator<TSource, TKey, TElement> : IIListProvider<IGrouping<TKey, TElement>>
+        internal sealed partial class GroupByIterator<TSource, TKey, TElement>
         {
-            public IGrouping<TKey, TElement>[] ToArray() =>
+            public override IGrouping<TKey, TElement>[] ToArray() =>
                 Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray();
 
-            public List<IGrouping<TKey, TElement>> ToList() =>
+            public override List<IGrouping<TKey, TElement>> ToList() =>
                 Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToList();
 
-            public int GetCount(bool onlyIfCheap) =>
+            public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
         }
 
-        internal sealed partial class GroupByIterator<TSource, TKey> : IIListProvider<IGrouping<TKey, TSource>>
+        internal sealed partial class GroupByIterator<TSource, TKey>
         {
-            public IGrouping<TKey, TSource>[] ToArray() =>
+            public override IGrouping<TKey, TSource>[] ToArray() =>
                 Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray();
 
-            public List<IGrouping<TKey, TSource>> ToList() =>
+            public override List<IGrouping<TKey, TSource>> ToList() =>
                 Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToList();
 
-            public int GetCount(bool onlyIfCheap) =>
+            public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
         }
     }
diff --git a/src/libraries/System.Linq/src/System/Linq/IIListProvider.cs b/src/libraries/System.Linq/src/System/Linq/IIListProvider.cs
deleted file mode 100644
index 9eefc6e61e0ce4..00000000000000
--- a/src/libraries/System.Linq/src/System/Linq/IIListProvider.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Generic;
-
-namespace System.Linq
-{
-    /// <summary>
-    /// An iterator that can produce an array or <see cref="List{TElement}"/> through an optimized path.
-    /// </summary>
-    internal interface IIListProvider<TElement> : IEnumerable<TElement>
-    {
-        /// <summary>
-        /// Produce an array of the sequence through an optimized path.
-        /// </summary>
-        /// <returns>The array.</returns>
-        TElement[] ToArray();
-
-        /// <summary>
-        /// Produce a <see cref="List{TElement}"/> of the sequence through an optimized path.
-        /// </summary>
-        /// <returns>The <see cref="List{TElement}"/>.</returns>
-        List<TElement> ToList();
-
-        /// <summary>
-        /// Returns the count of elements in the sequence.
-        /// </summary>
-        /// <param name="onlyIfCheap">If true then the count should only be calculated if doing
-        /// so is quick (sure or likely to be constant time), otherwise -1 should be returned.</param>
-        /// <returns>The number of elements.</returns>
-        int GetCount(bool onlyIfCheap);
-    }
-}
diff --git a/src/libraries/System.Linq/src/System/Linq/IPartition.cs b/src/libraries/System.Linq/src/System/Linq/IPartition.cs
deleted file mode 100644
index 86db1921b12f61..00000000000000
--- a/src/libraries/System.Linq/src/System/Linq/IPartition.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Linq
-{
-    /// <summary>
-    /// An iterator that supports random access and can produce a partial sequence of its items through an optimized path.
-    /// </summary>
-    internal interface IPartition<TElement> : IIListProvider<TElement>
-    {
-        /// <summary>
-        /// Creates a new partition that skips the specified number of elements from this sequence.
-        /// </summary>
-        /// <param name="count">The number of elements to skip.</param>
-        /// <returns>An <see cref="IPartition{TElement}"/> with the first <paramref name="count"/> items removed, or null if known empty.</returns>
-        IPartition<TElement>? Skip(int count);
-
-        /// <summary>
-        /// Creates a new partition that takes the specified number of elements from this sequence.
-        /// </summary>
-        /// <param name="count">The number of elements to take.</param>
-        /// <returns>An <see cref="IPartition{TElement}"/> with only the first <paramref name="count"/> items, or null if known empty.</returns>
-        IPartition<TElement>? Take(int count);
-
-        /// <summary>
-        /// Gets the item associated with a 0-based index in this sequence.
-        /// </summary>
-        /// <param name="index">The 0-based index to access.</param>
-        /// <param name="found"><c>true</c> if the sequence contains an element at that index, <c>false</c> otherwise.</param>
-        /// <returns>The element if <paramref name="found"/> is <c>true</c>, otherwise, the default value of <typeparamref name="TElement"/>.</returns>
-        TElement? TryGetElementAt(int index, out bool found);
-
-        /// <summary>
-        /// Gets the first item in this sequence.
-        /// </summary>
-        /// <param name="found"><c>true</c> if the sequence contains an element, <c>false</c> otherwise.</param>
-        /// <returns>The element if <paramref name="found"/> is <c>true</c>, otherwise, the default value of <typeparamref name="TElement"/>.</returns>
-        TElement? TryGetFirst(out bool found);
-
-        /// <summary>
-        /// Gets the last item in this sequence.
-        /// </summary>
-        /// <param name="found"><c>true</c> if the sequence contains an element, <c>false</c> otherwise.</param>
-        /// <returns>The element if <paramref name="found"/> is <c>true</c>, otherwise, the default value of <typeparamref name="TElement"/>.</returns>
-        TElement? TryGetLast(out bool found);
-    }
-}
diff --git a/src/libraries/System.Linq/src/System/Linq/Iterator.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Iterator.SpeedOpt.cs
new file mode 100644
index 00000000000000..d641faa93e3a1f
--- /dev/null
+++ b/src/libraries/System.Linq/src/System/Linq/Iterator.SpeedOpt.cs
@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+namespace System.Linq
+{
+    public static partial class Enumerable
+    {
+        internal abstract partial class Iterator<TSource>
+        {
+            /// <summary>
+            /// Produce an array of the sequence through an optimized path.
+            /// </summary>
+            /// <returns>The array.</returns>
+            public abstract TSource[] ToArray();
+
+            /// <summary>
+            /// Produce a <see cref="List{TSource}"/> of the sequence through an optimized path.
+            /// </summary>
+            /// <returns>The <see cref="List{TSource}"/>.</returns>
+            public abstract List<TSource> ToList();
+
+            /// <summary>
+            /// Returns the count of elements in the sequence.
+            /// </summary>
+            /// <param name="onlyIfCheap">If true then the count should only be calculated if doing
+            /// so is quick (sure or likely to be constant time), otherwise -1 should be returned.</param>
+            /// <returns>The number of elements.</returns>
+            public abstract int GetCount(bool onlyIfCheap);
+
+            /// <summary>
+            /// Creates a new iterator that skips the specified number of elements from this sequence.
+            /// </summary>
+            /// <param name="count">The number of elements to skip.</param>
+            /// <returns>An <see cref="Iterator{TSource}"/> with the first <paramref name="count"/> items removed, or null if known empty.</returns>
+            public virtual Iterator<TSource>? Skip(int count) => new IEnumerableSkipTakeIterator<TSource>(this, count, -1);
+
+            /// <summary>
+            /// Creates a new iterator that takes the specified number of elements from this sequence.
+            /// </summary>
+            /// <param name="count">The number of elements to take.</param>
+            /// <returns>An <see cref="Iterator{TSource}"/> with only the first <paramref name="count"/> items, or null if known empty.</returns>
+            public virtual Iterator<TSource>? Take(int count) => new IEnumerableSkipTakeIterator<TSource>(this, 0, count - 1);
+
+            /// <summary>
+            /// Gets the item associated with a 0-based index in this sequence.
+            /// </summary>
+            /// <param name="index">The 0-based index to access.</param>
+            /// <param name="found"><c>true</c> if the sequence contains an element at that index, <c>false</c> otherwise.</param>
+            /// <returns>The element if <paramref name="found"/> is <c>true</c>, otherwise, the default value of <typeparamref name="TSource"/>.</returns>
+            public virtual TSource? TryGetElementAt(int index, out bool found) =>
+                index == 0 ? TryGetFirst(out found) :
+                TryGetElementAtNonIterator(this, index, out found);
+
+            /// <summary>
+            /// Gets the first item in this sequence.
+            /// </summary>
+            /// <param name="found"><c>true</c> if the sequence contains an element, <c>false</c> otherwise.</param>
+            /// <returns>The element if <paramref name="found"/> is <c>true</c>, otherwise, the default value of <typeparamref name="TSource"/>.</returns>
+            public virtual TSource? TryGetFirst(out bool found) => TryGetFirstNonIterator(this, out found);
+
+            /// <summary>
+            /// Gets the last item in this sequence.
+            /// </summary>
+            /// <param name="found"><c>true</c> if the sequence contains an element, <c>false</c> otherwise.</param>
+            /// <returns>The element if <paramref name="found"/> is <c>true</c>, otherwise, the default value of <typeparamref name="TSource"/>.</returns>
+            public virtual TSource? TryGetLast(out bool found) => TryGetLastNonIterator(this, out found);
+        }
+    }
+}
diff --git a/src/libraries/System.Linq/src/System/Linq/Iterator.cs b/src/libraries/System.Linq/src/System/Linq/Iterator.cs
index b9e8c7b58c0548..933868212428bf 100644
--- a/src/libraries/System.Linq/src/System/Linq/Iterator.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Iterator.cs
@@ -28,20 +28,13 @@ public static partial class Enumerable
         /// </description></item>
         /// </list>
         /// </remarks>
-        internal abstract class Iterator<TSource> : IEnumerable<TSource>, IEnumerator<TSource>
+        internal abstract partial class Iterator<TSource> : IEnumerable<TSource>, IEnumerator<TSource>
         {
-            private readonly int _threadId;
+            private readonly int _threadId = Environment.CurrentManagedThreadId;
+
             internal int _state;
             internal TSource _current = default!;
 
-            /// <summary>
-            /// Initializes a new instance of the <see cref="Iterator{TSource}"/> class.
-            /// </summary>
-            protected Iterator()
-            {
-                _threadId = Environment.CurrentManagedThreadId;
-            }
-
             /// <summary>
             /// The item currently yielded by this iterator.
             /// </summary>
@@ -94,19 +87,21 @@ public IEnumerator<TSource> GetEnumerator()
             /// </summary>
             /// <typeparam name="TResult">The type of the mapped items.</typeparam>
             /// <param name="selector">The selector used to map each item.</param>
-            public virtual IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
-            {
-                return new SelectEnumerableIterator<TSource, TResult>(this, selector);
-            }
+            public virtual IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
+                new
+#if OPTIMIZE_FOR_SIZE
+                IEnumerableSelectIterator
+#else
+                IteratorSelectIterator
+#endif
+                <TSource, TResult>(this, selector);
 
             /// <summary>
             /// Returns an enumerable that filters each item in this iterator based on a predicate.
             /// </summary>
             /// <param name="predicate">The predicate used to filter each item.</param>
-            public virtual IEnumerable<TSource> Where(Func<TSource, bool> predicate)
-            {
-                return new WhereEnumerableIterator<TSource>(this, predicate);
-            }
+            public virtual IEnumerable<TSource> Where(Func<TSource, bool> predicate) =>
+                new IEnumerableWhereIterator<TSource>(this, predicate);
 
             object? IEnumerator.Current => Current;
 
diff --git a/src/libraries/System.Linq/src/System/Linq/Last.cs b/src/libraries/System.Linq/src/System/Linq/Last.cs
index 568f0d8670faf8..e7052c2b48dd6d 100644
--- a/src/libraries/System.Linq/src/System/Linq/Last.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Last.cs
@@ -68,11 +68,15 @@ public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, F
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            if (source is IPartition<TSource> partition)
-            {
-                return partition.TryGetLast(out found);
-            }
+            return
+#if !OPTIMIZE_FOR_SIZE
+                source is Iterator<TSource> iterator ? iterator.TryGetLast(out found) :
+#endif
+                TryGetLastNonIterator(source, out found);
+        }
 
+        private static TSource? TryGetLastNonIterator<TSource>(IEnumerable<TSource> source, out bool found)
+        {
             if (source is IList<TSource> list)
             {
                 int count = list.Count;
@@ -117,7 +121,7 @@ public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, F
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.predicate);
             }
 
-            if (source is OrderedEnumerable<TSource> ordered)
+            if (source is OrderedIterator<TSource> ordered)
             {
                 return ordered.TryGetLast(predicate, out found);
             }
diff --git a/src/libraries/System.Linq/src/System/Linq/OrderBy.cs b/src/libraries/System.Linq/src/System/Linq/OrderBy.cs
index aa7a08ee81c9f6..700410fe579f3f 100644
--- a/src/libraries/System.Linq/src/System/Linq/OrderBy.cs
+++ b/src/libraries/System.Linq/src/System/Linq/OrderBy.cs
@@ -44,14 +44,14 @@ public static IOrderedEnumerable<T> Order<T>(this IEnumerable<T> source) =>
         /// </remarks>
         public static IOrderedEnumerable<T> Order<T>(this IEnumerable<T> source, IComparer<T>? comparer) =>
             TypeIsImplicitlyStable<T>() && (comparer is null || comparer == Comparer<T>.Default) ?
-                new OrderedImplicitlyStableEnumerable<T>(source, descending: false) :
+                new ImplicitlyStableOrderedIterator<T>(source, descending: false) :
                 OrderBy(source, EnumerableSorter<T>.IdentityFunc, comparer);
 
         public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
-            => new OrderedEnumerable<TSource, TKey>(source, keySelector, null, false, null);
+            => new OrderedIterator<TSource, TKey>(source, keySelector, null, false, null);
 
         public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey>? comparer)
-            => new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, false, null);
+            => new OrderedIterator<TSource, TKey>(source, keySelector, comparer, false, null);
 
         /// <summary>
         /// Sorts the elements of a sequence in descending order.
@@ -89,14 +89,14 @@ public static IOrderedEnumerable<T> OrderDescending<T>(this IEnumerable<T> sourc
         /// </remarks>
         public static IOrderedEnumerable<T> OrderDescending<T>(this IEnumerable<T> source, IComparer<T>? comparer) =>
             TypeIsImplicitlyStable<T>() && (comparer is null || comparer == Comparer<T>.Default) ?
-                new OrderedImplicitlyStableEnumerable<T>(source, descending: true) :
+                new ImplicitlyStableOrderedIterator<T>(source, descending: true) :
                 OrderByDescending(source, EnumerableSorter<T>.IdentityFunc, comparer);
 
         public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) =>
-            new OrderedEnumerable<TSource, TKey>(source, keySelector, null, true, null);
+            new OrderedIterator<TSource, TKey>(source, keySelector, null, true, null);
 
         public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey>? comparer) =>
-            new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, true, null);
+            new OrderedIterator<TSource, TKey>(source, keySelector, comparer, true, null);
 
         public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
         {
diff --git a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs
index a666f9f1df5748..ffa533dd84e6f3 100644
--- a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.SpeedOpt.cs
@@ -10,9 +10,9 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        internal abstract partial class OrderedEnumerable<TElement> : IPartition<TElement>
+        internal abstract partial class OrderedIterator<TElement>
         {
-            public virtual TElement[] ToArray()
+            public override TElement[] ToArray()
             {
                 TElement[] buffer = _source.ToArray();
                 if (buffer.Length == 0)
@@ -25,7 +25,7 @@ public virtual TElement[] ToArray()
                 return array;
             }
 
-            public virtual List<TElement> ToList()
+            public override List<TElement> ToList()
             {
                 TElement[] buffer = _source.ToArray();
 
@@ -47,11 +47,11 @@ private void Fill(TElement[] buffer, Span<TElement> destination)
                 }
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
-                if (_source is IIListProvider<TElement> listProv)
+                if (_source is Iterator<TElement> iterator)
                 {
-                    return listProv.GetCount(onlyIfCheap);
+                    return iterator.GetCount(onlyIfCheap);
                 }
 
                 return !onlyIfCheap || _source is ICollection<TElement> || _source is ICollection ? _source.Count() : -1;
@@ -133,11 +133,11 @@ internal int GetCount(int minIdx, int maxIdx, bool onlyIfCheap)
                 return (count <= maxIdx ? count : maxIdx + 1) - minIdx;
             }
 
-            public IPartition<TElement> Skip(int count) => new OrderedPartition<TElement>(this, count, int.MaxValue);
+            public override Iterator<TElement> Skip(int count) => new SkipTakeOrderedIterator<TElement>(this, count, int.MaxValue);
 
-            public IPartition<TElement> Take(int count) => new OrderedPartition<TElement>(this, 0, count - 1);
+            public override Iterator<TElement> Take(int count) => new SkipTakeOrderedIterator<TElement>(this, 0, count - 1);
 
-            public TElement? TryGetElementAt(int index, out bool found)
+            public override TElement? TryGetElementAt(int index, out bool found)
             {
                 if (index == 0)
                 {
@@ -158,7 +158,7 @@ internal int GetCount(int minIdx, int maxIdx, bool onlyIfCheap)
                 return default;
             }
 
-            public virtual TElement? TryGetFirst(out bool found)
+            public override TElement? TryGetFirst(out bool found)
             {
                 CachingComparer<TElement> comparer = GetComparer();
                 using (IEnumerator<TElement> e = _source.GetEnumerator())
@@ -185,7 +185,7 @@ internal int GetCount(int minIdx, int maxIdx, bool onlyIfCheap)
                 }
             }
 
-            public virtual TElement? TryGetLast(out bool found)
+            public override TElement? TryGetLast(out bool found)
             {
                 using (IEnumerator<TElement> e = _source.GetEnumerator())
                 {
@@ -247,7 +247,7 @@ private TElement Last(TElement[] items)
             }
         }
 
-        internal sealed partial class OrderedEnumerable<TElement, TKey> : OrderedEnumerable<TElement>
+        internal sealed partial class OrderedIterator<TElement, TKey> : OrderedIterator<TElement>
         {
             // For complicated cases, rely on the base implementation that's more comprehensive.
             // For the simple case of OrderBy(...).First() or OrderByDescending(...).First() (i.e. where
@@ -358,7 +358,7 @@ internal sealed partial class OrderedEnumerable<TElement, TKey> : OrderedEnumera
             }
         }
 
-        internal sealed partial class OrderedImplicitlyStableEnumerable<TElement> : OrderedEnumerable<TElement>
+        internal sealed partial class ImplicitlyStableOrderedIterator<TElement> : OrderedIterator<TElement>
         {
             public override TElement[] ToArray()
             {
@@ -435,9 +435,9 @@ public override List<TElement> ToList()
             }
         }
 
-        internal sealed class OrderedPartition<TElement> : Iterator<TElement>, IPartition<TElement>
+        internal sealed class SkipTakeOrderedIterator<TElement> : Iterator<TElement>
         {
-            private readonly OrderedEnumerable<TElement> _source;
+            private readonly OrderedIterator<TElement> _source;
             private readonly int _minIndexInclusive;
             private readonly int _maxIndexInclusive;
 
@@ -445,20 +445,20 @@ internal sealed class OrderedPartition<TElement> : Iterator<TElement>, IPartitio
             private int[]? _map;
             private int _maxIdx;
 
-            public OrderedPartition(OrderedEnumerable<TElement> source, int minIdxInclusive, int maxIdxInclusive)
+            public SkipTakeOrderedIterator(OrderedIterator<TElement> source, int minIdxInclusive, int maxIdxInclusive)
             {
                 _source = source;
                 _minIndexInclusive = minIdxInclusive;
                 _maxIndexInclusive = maxIdxInclusive;
             }
 
-            public override Iterator<TElement> Clone() => new OrderedPartition<TElement>(_source, _minIndexInclusive, _maxIndexInclusive);
+            public override Iterator<TElement> Clone() => new SkipTakeOrderedIterator<TElement>(_source, _minIndexInclusive, _maxIndexInclusive);
 
             public override bool MoveNext()
             {
                 int state = _state;
 
-            Initialized:
+                Initialized:
                 if (state > 1)
                 {
                     Debug.Assert(_buffer is not null);
@@ -503,13 +503,13 @@ public override bool MoveNext()
                 return false;
             }
 
-            public IPartition<TElement>? Skip(int count)
+            public override Iterator<TElement>? Skip(int count)
             {
                 int minIndex = _minIndexInclusive + count;
-                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new OrderedPartition<TElement>(_source, minIndex, _maxIndexInclusive);
+                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new SkipTakeOrderedIterator<TElement>(_source, minIndex, _maxIndexInclusive);
             }
 
-            public IPartition<TElement> Take(int count)
+            public override Iterator<TElement> Take(int count)
             {
                 int maxIndex = _minIndexInclusive + count - 1;
                 if ((uint)maxIndex >= (uint)_maxIndexInclusive)
@@ -517,10 +517,10 @@ public IPartition<TElement> Take(int count)
                     return this;
                 }
 
-                return new OrderedPartition<TElement>(_source, _minIndexInclusive, maxIndex);
+                return new SkipTakeOrderedIterator<TElement>(_source, _minIndexInclusive, maxIndex);
             }
 
-            public TElement? TryGetElementAt(int index, out bool found)
+            public override TElement? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive))
                 {
@@ -531,16 +531,16 @@ public IPartition<TElement> Take(int count)
                 return default;
             }
 
-            public TElement? TryGetFirst(out bool found) => _source.TryGetElementAt(_minIndexInclusive, out found);
+            public override TElement? TryGetFirst(out bool found) => _source.TryGetElementAt(_minIndexInclusive, out found);
 
-            public TElement? TryGetLast(out bool found) =>
+            public override TElement? TryGetLast(out bool found) =>
                 _source.TryGetLast(_minIndexInclusive, _maxIndexInclusive, out found);
 
-            public TElement[] ToArray() => _source.ToArray(_minIndexInclusive, _maxIndexInclusive);
+            public override TElement[] ToArray() => _source.ToArray(_minIndexInclusive, _maxIndexInclusive);
 
-            public List<TElement> ToList() => _source.ToList(_minIndexInclusive, _maxIndexInclusive);
+            public override List<TElement> ToList() => _source.ToList(_minIndexInclusive, _maxIndexInclusive);
 
-            public int GetCount(bool onlyIfCheap) => _source.GetCount(_minIndexInclusive, _maxIndexInclusive, onlyIfCheap);
+            public override int GetCount(bool onlyIfCheap) => _source.GetCount(_minIndexInclusive, _maxIndexInclusive, onlyIfCheap);
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
index b87f4fbc3dadc5..40ee075a9b3141 100644
--- a/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
+++ b/src/libraries/System.Linq/src/System/Linq/OrderedEnumerable.cs
@@ -9,11 +9,11 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        internal abstract partial class OrderedEnumerable<TElement> : Iterator<TElement>, IOrderedEnumerable<TElement>
+        internal abstract partial class OrderedIterator<TElement> : Iterator<TElement>, IOrderedEnumerable<TElement>
         {
             internal readonly IEnumerable<TElement> _source;
 
-            protected OrderedEnumerable(IEnumerable<TElement> source) => _source = source;
+            protected OrderedIterator(IEnumerable<TElement> source) => _source = source;
 
             private protected int[] SortedMap(TElement[] buffer) => GetEnumerableSorter().Sort(buffer, buffer.Length);
 
@@ -27,7 +27,7 @@ internal int[] SortedMap(TElement[] buffer, int minIdx, int maxIdx) =>
             IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
             IOrderedEnumerable<TElement> IOrderedEnumerable<TElement>.CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey>? comparer, bool descending) =>
-                new OrderedEnumerable<TElement, TKey>(_source, keySelector, comparer, @descending, this);
+                new OrderedIterator<TElement, TKey>(_source, keySelector, comparer, @descending, this);
 
             public TElement? TryGetLast(Func<TElement, bool> predicate, out bool found)
             {
@@ -63,16 +63,16 @@ IOrderedEnumerable<TElement> IOrderedEnumerable<TElement>.CreateOrderedEnumerabl
             }
         }
 
-        internal sealed partial class OrderedEnumerable<TElement, TKey> : OrderedEnumerable<TElement>
+        internal sealed partial class OrderedIterator<TElement, TKey> : OrderedIterator<TElement>
         {
-            private readonly OrderedEnumerable<TElement>? _parent;
+            private readonly OrderedIterator<TElement>? _parent;
             private readonly Func<TElement, TKey> _keySelector;
             private readonly IComparer<TKey> _comparer;
             private readonly bool _descending;
             private TElement[]? _buffer;
             private int[]? _map;
 
-            internal OrderedEnumerable(IEnumerable<TElement> source, Func<TElement, TKey> keySelector, IComparer<TKey>? comparer, bool descending, OrderedEnumerable<TElement>? parent) :
+            internal OrderedIterator(IEnumerable<TElement> source, Func<TElement, TKey> keySelector, IComparer<TKey>? comparer, bool descending, OrderedIterator<TElement>? parent) :
                 base(source)
             {
                 if (source is null)
@@ -90,7 +90,7 @@ internal OrderedEnumerable(IEnumerable<TElement> source, Func<TElement, TKey> ke
                 _descending = descending;
             }
 
-            public override Iterator<TElement> Clone() => new OrderedEnumerable<TElement, TKey>(_source, _keySelector, _comparer, _descending, _parent);
+            public override Iterator<TElement> Clone() => new OrderedIterator<TElement, TKey>(_source, _keySelector, _comparer, _descending, _parent);
 
             internal override EnumerableSorter<TElement> GetEnumerableSorter(EnumerableSorter<TElement>? next)
             {
@@ -165,12 +165,12 @@ public override void Dispose()
         }
 
         /// <summary>An ordered enumerable used by Order/OrderDescending for Ts that are bitwise indistinguishable for any considered equal.</summary>
-        internal sealed partial class OrderedImplicitlyStableEnumerable<TElement> : OrderedEnumerable<TElement>
+        internal sealed partial class ImplicitlyStableOrderedIterator<TElement> : OrderedIterator<TElement>
         {
             private readonly bool _descending;
             private TElement[]? _buffer;
 
-            public OrderedImplicitlyStableEnumerable(IEnumerable<TElement> source, bool descending) : base(source)
+            public ImplicitlyStableOrderedIterator(IEnumerable<TElement> source, bool descending) : base(source)
             {
                 Debug.Assert(TypeIsImplicitlyStable<TElement>());
 
@@ -182,7 +182,7 @@ public OrderedImplicitlyStableEnumerable(IEnumerable<TElement> source, bool desc
                 _descending = descending;
             }
 
-            public override Iterator<TElement> Clone() => new OrderedImplicitlyStableEnumerable<TElement>(_source, _descending);
+            public override Iterator<TElement> Clone() => new ImplicitlyStableOrderedIterator<TElement>(_source, _descending);
 
             internal override CachingComparer<TElement> GetComparer(CachingComparer<TElement>? childComparer) =>
                 childComparer == null ?
diff --git a/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
index b8e3d32c282747..021097de87b42a 100644
--- a/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
@@ -13,13 +13,13 @@ public static partial class Enumerable
         /// </summary>
         /// <typeparam name="TSource">The type of the source list.</typeparam>
         [DebuggerDisplay("Count = {Count}")]
-        private sealed class ListPartition<TSource> : Iterator<TSource>, IPartition<TSource>, IList<TSource>, IReadOnlyList<TSource>
+        private sealed class IListSkipTakeIterator<TSource> : Iterator<TSource>, IList<TSource>, IReadOnlyList<TSource>
         {
             private readonly IList<TSource> _source;
             private readonly int _minIndexInclusive;
             private readonly int _maxIndexInclusive;
 
-            public ListPartition(IList<TSource> source, int minIndexInclusive, int maxIndexInclusive)
+            public IListSkipTakeIterator(IList<TSource> source, int minIndexInclusive, int maxIndexInclusive)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(minIndexInclusive >= 0);
@@ -30,7 +30,7 @@ public ListPartition(IList<TSource> source, int minIndexInclusive, int maxIndexI
             }
 
             public override Iterator<TSource> Clone() =>
-                new ListPartition<TSource>(_source, _minIndexInclusive, _maxIndexInclusive);
+                new IListSkipTakeIterator<TSource>(_source, _minIndexInclusive, _maxIndexInclusive);
 
             public override bool MoveNext()
             {
@@ -50,21 +50,21 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-                new SelectListPartitionIterator<TSource, TResult>(_source, selector, _minIndexInclusive, _maxIndexInclusive);
+                new IListSkipTakeSelectIterator<TSource, TResult>(_source, selector, _minIndexInclusive, _maxIndexInclusive);
 
-            public IPartition<TSource>? Skip(int count)
+            public override Iterator<TSource>? Skip(int count)
             {
                 int minIndex = _minIndexInclusive + count;
-                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new ListPartition<TSource>(_source, minIndex, _maxIndexInclusive);
+                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new IListSkipTakeIterator<TSource>(_source, minIndex, _maxIndexInclusive);
             }
 
-            public IPartition<TSource> Take(int count)
+            public override Iterator<TSource> Take(int count)
             {
                 int maxIndex = _minIndexInclusive + count - 1;
-                return (uint)maxIndex >= (uint)_maxIndexInclusive ? this : new ListPartition<TSource>(_source, _minIndexInclusive, maxIndex);
+                return (uint)maxIndex >= (uint)_maxIndexInclusive ? this : new IListSkipTakeIterator<TSource>(_source, _minIndexInclusive, maxIndex);
             }
 
-            public TSource? TryGetElementAt(int index, out bool found)
+            public override TSource? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive) && index < _source.Count - _minIndexInclusive)
                 {
@@ -76,7 +76,7 @@ public IPartition<TSource> Take(int count)
                 return default;
             }
 
-            public TSource? TryGetFirst(out bool found)
+            public override TSource? TryGetFirst(out bool found)
             {
                 if (_source.Count > _minIndexInclusive)
                 {
@@ -88,7 +88,7 @@ public IPartition<TSource> Take(int count)
                 return default;
             }
 
-            public TSource? TryGetLast(out bool found)
+            public override TSource? TryGetLast(out bool found)
             {
                 int lastIndex = _source.Count - 1;
                 if (lastIndex >= _minIndexInclusive)
@@ -115,9 +115,9 @@ public int Count
                 }
             }
 
-            public int GetCount(bool onlyIfCheap) => Count;
+            public override int GetCount(bool onlyIfCheap) => Count;
 
-            public TSource[] ToArray()
+            public override TSource[] ToArray()
             {
                 int count = Count;
                 if (count == 0)
@@ -130,16 +130,16 @@ public TSource[] ToArray()
                 return array;
             }
 
-            public List<TSource> ToList()
+            public override List<TSource> ToList()
             {
                 int count = Count;
-                if (count == 0)
+
+                List<TSource> list = [];
+                if (count != 0)
                 {
-                    return new List<TSource>();
+                    Fill(_source, SetCountAndGetSpan(list, count), _minIndexInclusive);
                 }
 
-                List<TSource> list = new List<TSource>(count);
-                Fill(_source, SetCountAndGetSpan(list, count), _minIndexInclusive);
                 return list;
             }
 
@@ -199,7 +199,7 @@ public TSource this[int index]
         /// An iterator that yields the items of part of an <see cref="IEnumerable{TSource}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the source enumerable.</typeparam>
-        private sealed class EnumerablePartition<TSource> : Iterator<TSource>, IPartition<TSource>
+        private sealed class IEnumerableSkipTakeIterator<TSource> : Iterator<TSource>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly int _minIndexInclusive;
@@ -207,7 +207,7 @@ private sealed class EnumerablePartition<TSource> : Iterator<TSource>, IPartitio
                                                      // If this is -1, it's impossible to set a limit on the count.
             private IEnumerator<TSource>? _enumerator;
 
-            internal EnumerablePartition(IEnumerable<TSource> source, int minIndexInclusive, int maxIndexInclusive)
+            internal IEnumerableSkipTakeIterator(IEnumerable<TSource> source, int minIndexInclusive, int maxIndexInclusive)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(!(source is IList<TSource>), $"The caller needs to check for {nameof(IList<TSource>)}.");
@@ -231,7 +231,7 @@ internal EnumerablePartition(IEnumerable<TSource> source, int minIndexInclusive,
             private int Limit => _maxIndexInclusive + 1 - _minIndexInclusive; // This is that upper bound.
 
             public override Iterator<TSource> Clone() =>
-                new EnumerablePartition<TSource>(_source, _minIndexInclusive, _maxIndexInclusive);
+                new IEnumerableSkipTakeIterator<TSource>(_source, _minIndexInclusive, _maxIndexInclusive);
 
             public override void Dispose()
             {
@@ -244,7 +244,7 @@ public override void Dispose()
                 base.Dispose();
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 if (onlyIfCheap)
                 {
@@ -261,7 +261,7 @@ public int GetCount(bool onlyIfCheap)
                 using (IEnumerator<TSource> en = _source.GetEnumerator())
                 {
                     // We only want to iterate up to _maxIndexInclusive + 1.
-                    // Past that, we know the enumerable will be able to fit this partition,
+                    // Past that, we know the enumerable will be able to fit this subset,
                     // so the count will just be _maxIndexInclusive + 1 - _minIndexInclusive.
 
                     // Note that it is possible for _maxIndexInclusive to be int.MaxValue here,
@@ -273,7 +273,6 @@ public int GetCount(bool onlyIfCheap)
                     Debug.Assert(count != (uint)int.MaxValue + 1 || _minIndexInclusive > 0, "Our return value will be incorrect.");
                     return Math.Max((int)count - _minIndexInclusive, 0);
                 }
-
             }
 
             public override bool MoveNext()
@@ -325,10 +324,7 @@ public override bool MoveNext()
                 return false;
             }
 
-            public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-                new SelectIPartitionIterator<TSource, TResult>(this, selector);
-
-            public IPartition<TSource>? Skip(int count)
+            public override Iterator<TSource>? Skip(int count)
             {
                 int minIndex = _minIndexInclusive + count;
 
@@ -339,7 +335,7 @@ public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> sele
                         // If we don't know our max count and minIndex can no longer fit in a positive int,
                         // then we will need to wrap ourselves in another iterator.
                         // This can happen, for example, during e.Skip(int.MaxValue).Skip(int.MaxValue).
-                        return new EnumerablePartition<TSource>(this, count, -1);
+                        return new IEnumerableSkipTakeIterator<TSource>(this, count, -1);
                     }
                 }
                 else if ((uint)minIndex > (uint)_maxIndexInclusive)
@@ -351,10 +347,10 @@ public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> sele
                 }
 
                 Debug.Assert(minIndex >= 0, $"We should have taken care of all cases when {nameof(minIndex)} overflows.");
-                return new EnumerablePartition<TSource>(_source, minIndex, _maxIndexInclusive);
+                return new IEnumerableSkipTakeIterator<TSource>(_source, minIndex, _maxIndexInclusive);
             }
 
-            public IPartition<TSource> Take(int count)
+            public override Iterator<TSource> Take(int count)
             {
                 int maxIndex = _minIndexInclusive + count - 1;
                 if (!HasLimit)
@@ -367,7 +363,7 @@ public IPartition<TSource> Take(int count)
                         // _minIndexInclusive (which is count - 1) must fit in an int.
                         // Example: e.Skip(50).Take(int.MaxValue).
 
-                        return new EnumerablePartition<TSource>(this, 0, count - 1);
+                        return new IEnumerableSkipTakeIterator<TSource>(this, 0, count - 1);
                     }
                 }
                 else if ((uint)maxIndex >= (uint)_maxIndexInclusive)
@@ -379,18 +375,23 @@ public IPartition<TSource> Take(int count)
                 }
 
                 Debug.Assert(maxIndex >= 0, $"We should have taken care of all cases when {nameof(maxIndex)} overflows.");
-                return new EnumerablePartition<TSource>(_source, _minIndexInclusive, maxIndex);
+                return new IEnumerableSkipTakeIterator<TSource>(_source, _minIndexInclusive, maxIndex);
             }
 
-            public TSource? TryGetElementAt(int index, out bool found)
+            public override TSource? TryGetElementAt(int index, out bool found)
             {
                 // If the index is negative or >= our max count, return early.
                 if (index >= 0 && (!HasLimit || index < Limit))
                 {
-                    using (IEnumerator<TSource> en = _source.GetEnumerator())
+                    Debug.Assert(_minIndexInclusive + index >= 0, $"Adding {nameof(index)} caused {nameof(_minIndexInclusive)} to overflow.");
+
+                    if (_source is Iterator<TSource> iterator)
                     {
-                        Debug.Assert(_minIndexInclusive + index >= 0, $"Adding {nameof(index)} caused {nameof(_minIndexInclusive)} to overflow.");
+                        return iterator.TryGetElementAt(_minIndexInclusive + index, out found);
+                    }
 
+                    using (IEnumerator<TSource> en = _source.GetEnumerator())
+                    {
                         if (SkipBefore(_minIndexInclusive + index, en) && en.MoveNext())
                         {
                             found = true;
@@ -403,8 +404,15 @@ public IPartition<TSource> Take(int count)
                 return default;
             }
 
-            public TSource? TryGetFirst(out bool found)
+            public override TSource? TryGetFirst(out bool found)
             {
+                Debug.Assert(!HasLimit || Limit > 0);
+
+                if (_source is Iterator<TSource> iterator)
+                {
+                    return iterator.TryGetElementAt(_minIndexInclusive, out found);
+                }
+
                 using (IEnumerator<TSource> en = _source.GetEnumerator())
                 {
                     if (SkipBeforeFirst(en) && en.MoveNext())
@@ -418,8 +426,17 @@ public IPartition<TSource> Take(int count)
                 return default;
             }
 
-            public TSource? TryGetLast(out bool found)
+            public override TSource? TryGetLast(out bool found)
             {
+                if (_source is Iterator<TSource> iterator &&
+                    iterator.GetCount(onlyIfCheap: true) is int count &&
+                    count >= _minIndexInclusive)
+                {
+                    return !HasLimit ?
+                        iterator.TryGetLast(out found) :
+                        iterator.TryGetElementAt(_maxIndexInclusive, out found);
+                }
+
                 using (IEnumerator<TSource> en = _source.GetEnumerator())
                 {
                     if (SkipBeforeFirst(en) && en.MoveNext())
@@ -444,7 +461,7 @@ public IPartition<TSource> Take(int count)
                 return default;
             }
 
-            public TSource[] ToArray()
+            public override TSource[] ToArray()
             {
                 using (IEnumerator<TSource> en = _source.GetEnumerator())
                 {
@@ -472,7 +489,7 @@ public TSource[] ToArray()
                 return [];
             }
 
-            public List<TSource> ToList()
+            public override List<TSource> ToList()
             {
                 var list = new List<TSource>();
 
diff --git a/src/libraries/System.Linq/src/System/Linq/Range.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Range.SpeedOpt.cs
index c125673e16d36e..bde2cede4b1b9a 100644
--- a/src/libraries/System.Linq/src/System/Linq/Range.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Range.SpeedOpt.cs
@@ -10,14 +10,14 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class RangeIterator : IPartition<int>, IList<int>, IReadOnlyList<int>
+        private sealed partial class RangeIterator : IList<int>, IReadOnlyList<int>
         {
             public override IEnumerable<TResult> Select<TResult>(Func<int, TResult> selector)
             {
-                return new SelectRangeIterator<TResult>(_start, _end, selector);
+                return new RangeSelectIterator<TResult>(_start, _end, selector);
             }
 
-            public int[] ToArray()
+            public override int[] ToArray()
             {
                 int start = _start;
                 int[] array = new int[_end - start];
@@ -25,7 +25,7 @@ public int[] ToArray()
                 return array;
             }
 
-            public List<int> ToList()
+            public override List<int> ToList()
             {
                 (int start, int end) = (_start, _end);
                 List<int> list = new List<int>(end - start);
@@ -67,11 +67,11 @@ private static void Fill(Span<int> destination, int value)
                 }
             }
 
-            public int GetCount(bool onlyIfCheap) => _end - _start;
+            public override int GetCount(bool onlyIfCheap) => _end - _start;
 
             public int Count => _end - _start;
 
-            public IPartition<int>? Skip(int count)
+            public override Iterator<int>? Skip(int count)
             {
                 if (count >= _end - _start)
                 {
@@ -81,7 +81,7 @@ private static void Fill(Span<int> destination, int value)
                 return new RangeIterator(_start + count, _end - _start - count);
             }
 
-            public IPartition<int> Take(int count)
+            public override Iterator<int> Take(int count)
             {
                 int curCount = _end - _start;
                 if (count >= curCount)
@@ -92,7 +92,7 @@ public IPartition<int> Take(int count)
                 return new RangeIterator(_start, count);
             }
 
-            public int TryGetElementAt(int index, out bool found)
+            public override int TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index < (uint)(_end - _start))
                 {
@@ -104,13 +104,13 @@ public int TryGetElementAt(int index, out bool found)
                 return 0;
             }
 
-            public int TryGetFirst(out bool found)
+            public override int TryGetFirst(out bool found)
             {
                 found = true;
                 return _start;
             }
 
-            public int TryGetLast(out bool found)
+            public override int TryGetLast(out bool found)
             {
                 found = true;
                 return _end - 1;
diff --git a/src/libraries/System.Linq/src/System/Linq/Repeat.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Repeat.SpeedOpt.cs
index 3c25ee20ba5f2c..5ca5b2625b1078 100644
--- a/src/libraries/System.Linq/src/System/Linq/Repeat.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Repeat.SpeedOpt.cs
@@ -8,12 +8,9 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class RepeatIterator<TResult> : IPartition<TResult>, IList<TResult>, IReadOnlyList<TResult>
+        private sealed partial class RepeatIterator<TResult> : IList<TResult>, IReadOnlyList<TResult>
         {
-            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectIPartitionIterator<TResult, TResult2>(this, selector);
-
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 TResult[] array = new TResult[_count];
                 if (_current != null)
@@ -24,7 +21,7 @@ public TResult[] ToArray()
                 return array;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 List<TResult> list = new List<TResult>(_count);
                 SetCountAndGetSpan(list, _count).Fill(_current);
@@ -32,11 +29,11 @@ public List<TResult> ToList()
                 return list;
             }
 
-            public int GetCount(bool onlyIfCheap) => _count;
+            public override int GetCount(bool onlyIfCheap) => _count;
 
             public int Count => _count;
 
-            public IPartition<TResult>? Skip(int count)
+            public override Iterator<TResult>? Skip(int count)
             {
                 Debug.Assert(count > 0);
 
@@ -48,7 +45,7 @@ public List<TResult> ToList()
                 return new RepeatIterator<TResult>(_current, _count - count);
             }
 
-            public IPartition<TResult> Take(int count)
+            public override Iterator<TResult> Take(int count)
             {
                 Debug.Assert(count > 0);
 
@@ -60,7 +57,7 @@ public IPartition<TResult> Take(int count)
                 return new RepeatIterator<TResult>(_current, count);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index < (uint)_count)
                 {
@@ -72,13 +69,13 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult TryGetFirst(out bool found)
+            public override TResult TryGetFirst(out bool found)
             {
                 found = true;
                 return _current;
             }
 
-            public TResult TryGetLast(out bool found)
+            public override TResult TryGetLast(out bool found)
             {
                 found = true;
                 return _current;
diff --git a/src/libraries/System.Linq/src/System/Linq/Reverse.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Reverse.SpeedOpt.cs
index bb301cc3084899..d1ec26de879afd 100644
--- a/src/libraries/System.Linq/src/System/Linq/Reverse.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Reverse.SpeedOpt.cs
@@ -7,28 +7,28 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class ReverseIterator<TSource> : IPartition<TSource>
+        private sealed partial class ReverseIterator<TSource>
         {
-            public TSource[] ToArray()
+            public override TSource[] ToArray()
             {
                 TSource[] array = _source.ToArray();
                 Array.Reverse(array);
                 return array;
             }
 
-            public List<TSource> ToList()
+            public override List<TSource> ToList()
             {
                 List<TSource> list = _source.ToList();
                 list.Reverse();
                 return list;
             }
 
-            public int GetCount(bool onlyIfCheap) =>
+            public override int GetCount(bool onlyIfCheap) =>
                 !onlyIfCheap ? _source.Count() :
                 TryGetNonEnumeratedCount(_source, out int count) ? count :
                 -1;
 
-            public TSource? TryGetElementAt(int index, out bool found)
+            public override TSource? TryGetElementAt(int index, out bool found)
             {
                 if (_source is IList<TSource> list)
                 {
@@ -53,11 +53,11 @@ public int GetCount(bool onlyIfCheap) =>
                 return default;
             }
 
-            public TSource? TryGetFirst(out bool found)
+            public override TSource? TryGetFirst(out bool found)
             {
-                if (_source is IPartition<TSource> partition)
+                if (_source is Iterator<TSource> iterator)
                 {
-                    return partition.TryGetLast(out found);
+                    return iterator.TryGetLast(out found);
                 }
                 else if (_source is IList<TSource> list)
                 {
@@ -89,11 +89,11 @@ public int GetCount(bool onlyIfCheap) =>
                 return default;
             }
 
-            public TSource? TryGetLast(out bool found)
+            public override TSource? TryGetLast(out bool found)
             {
-                if (_source is IPartition<TSource> partition)
+                if (_source is Iterator<TSource> iterator)
                 {
-                    return partition.TryGetFirst(out found);
+                    return iterator.TryGetFirst(out found);
                 }
                 else if (_source is IList<TSource> list)
                 {
@@ -116,10 +116,6 @@ public int GetCount(bool onlyIfCheap) =>
                 found = false;
                 return default;
             }
-
-            public IPartition<TSource>? Skip(int count) => new EnumerablePartition<TSource>(this, count, -1);
-
-            public IPartition<TSource>? Take(int count) => new EnumerablePartition<TSource>(this, 0, count - 1);
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Select.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Select.SpeedOpt.cs
index 06f87db9c0f786..f55b656033e3ab 100644
--- a/src/libraries/System.Linq/src/System/Linq/Select.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Select.SpeedOpt.cs
@@ -10,15 +10,9 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        static partial void CreateSelectIPartitionIterator<TResult, TSource>(
-            Func<TSource, TResult> selector, IPartition<TSource> partition, ref IEnumerable<TResult>? result)
+        private sealed partial class IEnumerableSelectIterator<TSource, TResult>
         {
-            result = new SelectIPartitionIterator<TSource, TResult>(partition, selector);
-        }
-
-        private sealed partial class SelectEnumerableIterator<TSource, TResult> : IIListProvider<TResult>
-        {
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 SegmentedArrayBuilder<TResult>.ScratchBuffer scratch = default;
                 SegmentedArrayBuilder<TResult> builder = new(scratch);
@@ -35,7 +29,7 @@ public TResult[] ToArray()
                 return result;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 var list = new List<TResult>();
 
@@ -48,7 +42,7 @@ public List<TResult> ToList()
                 return list;
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of
                 // the selector, run it provided `onlyIfCheap` is false.
@@ -71,11 +65,73 @@ public int GetCount(bool onlyIfCheap)
 
                 return count;
             }
+
+            public override TResult? TryGetElementAt(int index, out bool found)
+            {
+                if (index >= 0)
+                {
+                    IEnumerator<TSource> e = _source.GetEnumerator();
+                    try
+                    {
+                        while (e.MoveNext())
+                        {
+                            if (index == 0)
+                            {
+                                found = true;
+                                return _selector(e.Current);
+                            }
+
+                            index--;
+                        }
+                    }
+                    finally
+                    {
+                        (e as IDisposable)?.Dispose();
+                    }
+                }
+
+                found = false;
+                return default;
+            }
+
+            public override TResult? TryGetFirst(out bool found)
+            {
+                using IEnumerator<TSource> e = _source.GetEnumerator();
+                if (e.MoveNext())
+                {
+                    found = true;
+                    return _selector(e.Current);
+                }
+
+                found = false;
+                return default;
+            }
+
+            public override TResult? TryGetLast(out bool found)
+            {
+                using IEnumerator<TSource> e = _source.GetEnumerator();
+
+                if (e.MoveNext())
+                {
+                    found = true;
+                    TSource last = e.Current;
+
+                    while (e.MoveNext())
+                    {
+                        last = e.Current;
+                    }
+
+                    return _selector(last);
+                }
+
+                found = false;
+                return default;
+            }
         }
 
-        private sealed partial class SelectArrayIterator<TSource, TResult> : IPartition<TResult>
+        private sealed partial class ArraySelectIterator<TSource, TResult>
         {
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 // See assert in constructor.
                 // Since _source should never be empty, we don't check for 0/return Array.Empty.
@@ -88,7 +144,7 @@ public TResult[] ToArray()
                 return results;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 TSource[] source = _source;
                 Debug.Assert(source.Length > 0);
@@ -107,7 +163,7 @@ private static void Fill(ReadOnlySpan<TSource> source, Span<TResult> destination
                 }
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of
                 // the selector, run it provided `onlyIfCheap` is false.
@@ -123,7 +179,7 @@ public int GetCount(bool onlyIfCheap)
                 return _source.Length;
             }
 
-            public IPartition<TResult>? Skip(int count)
+            public override Iterator<TResult>? Skip(int count)
             {
                 Debug.Assert(count > 0);
                 if (count >= _source.Length)
@@ -131,30 +187,31 @@ public int GetCount(bool onlyIfCheap)
                     return null;
                 }
 
-                return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
+                return new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
             }
 
-            public IPartition<TResult> Take(int count)
+            public override Iterator<TResult> Take(int count)
             {
                 Debug.Assert(count > 0);
                 return count >= _source.Length ?
                     this :
-                    new SelectListPartitionIterator<TSource, TResult>(_source, _selector, 0, count - 1);
+                    new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, 0, count - 1);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
-                if ((uint)index < (uint)_source.Length)
+                TSource[] source = _source;
+                if ((uint)index < (uint)source.Length)
                 {
                     found = true;
-                    return _selector(_source[index]);
+                    return _selector(source[index]);
                 }
 
                 found = false;
                 return default;
             }
 
-            public TResult TryGetFirst(out bool found)
+            public override TResult TryGetFirst(out bool found)
             {
                 Debug.Assert(_source.Length > 0); // See assert in constructor
 
@@ -162,22 +219,22 @@ public TResult TryGetFirst(out bool found)
                 return _selector(_source[0]);
             }
 
-            public TResult TryGetLast(out bool found)
+            public override TResult TryGetLast(out bool found)
             {
                 Debug.Assert(_source.Length > 0); // See assert in constructor
 
                 found = true;
-                return _selector(_source[_source.Length - 1]);
+                return _selector(_source[^1]);
             }
         }
 
-        private sealed partial class SelectRangeIterator<TResult> : Iterator<TResult>, IPartition<TResult>
+        private sealed partial class RangeSelectIterator<TResult> : Iterator<TResult>
         {
             private readonly int _start;
             private readonly int _end;
             private readonly Func<int, TResult> _selector;
 
-            public SelectRangeIterator(int start, int end, Func<int, TResult> selector)
+            public RangeSelectIterator(int start, int end, Func<int, TResult> selector)
             {
                 Debug.Assert(start < end);
                 Debug.Assert((uint)(end - start) <= (uint)int.MaxValue);
@@ -189,7 +246,7 @@ public SelectRangeIterator(int start, int end, Func<int, TResult> selector)
             }
 
             public override Iterator<TResult> Clone() =>
-                new SelectRangeIterator<TResult>(_start, _end, _selector);
+                new RangeSelectIterator<TResult>(_start, _end, _selector);
 
             public override bool MoveNext()
             {
@@ -206,9 +263,9 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectRangeIterator<TResult2>(_start, _end, CombineSelectors(_selector, selector));
+                new RangeSelectIterator<TResult2>(_start, _end, CombineSelectors(_selector, selector));
 
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 var results = new TResult[_end - _start];
                 Fill(results, _start, _selector);
@@ -216,7 +273,7 @@ public TResult[] ToArray()
                 return results;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 var results = new List<TResult>(_end - _start);
                 Fill(SetCountAndGetSpan(results, _end - _start), _start, _selector);
@@ -232,7 +289,7 @@ private static void Fill(Span<TResult> results, int start, Func<int, TResult> fu
                 }
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of the selector,
                 // run it provided `onlyIfCheap` is false.
@@ -247,7 +304,7 @@ public int GetCount(bool onlyIfCheap)
                 return _end - _start;
             }
 
-            public IPartition<TResult>? Skip(int count)
+            public override Iterator<TResult>? Skip(int count)
             {
                 Debug.Assert(count > 0);
 
@@ -256,10 +313,10 @@ public int GetCount(bool onlyIfCheap)
                     return null;
                 }
 
-                return new SelectRangeIterator<TResult>(_start + count, _end, _selector);
+                return new RangeSelectIterator<TResult>(_start + count, _end, _selector);
             }
 
-            public IPartition<TResult> Take(int count)
+            public override Iterator<TResult> Take(int count)
             {
                 Debug.Assert(count > 0);
 
@@ -268,10 +325,10 @@ public IPartition<TResult> Take(int count)
                     return this;
                 }
 
-                return new SelectRangeIterator<TResult>(_start, _start + count, _selector);
+                return new RangeSelectIterator<TResult>(_start, _start + count, _selector);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index < (uint)(_end - _start))
                 {
@@ -283,14 +340,14 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult TryGetFirst(out bool found)
+            public override TResult TryGetFirst(out bool found)
             {
                 Debug.Assert(_end > _start);
                 found = true;
                 return _selector(_start);
             }
 
-            public TResult TryGetLast(out bool found)
+            public override TResult TryGetLast(out bool found)
             {
                 Debug.Assert(_end > _start);
                 found = true;
@@ -298,9 +355,9 @@ public TResult TryGetLast(out bool found)
             }
         }
 
-        private sealed partial class SelectListIterator<TSource, TResult> : IPartition<TResult>
+        private sealed partial class ListSelectIterator<TSource, TResult>
         {
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 ReadOnlySpan<TSource> source = CollectionsMarshal.AsSpan(_source);
                 if (source.Length == 0)
@@ -314,7 +371,7 @@ public TResult[] ToArray()
                 return results;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 ReadOnlySpan<TSource> source = CollectionsMarshal.AsSpan(_source);
 
@@ -332,7 +389,7 @@ private static void Fill(ReadOnlySpan<TSource> source, Span<TResult> destination
                 }
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of
                 // the selector, run it provided `onlyIfCheap` is false.
@@ -350,19 +407,19 @@ public int GetCount(bool onlyIfCheap)
                 return count;
             }
 
-            public IPartition<TResult> Skip(int count)
+            public override Iterator<TResult> Skip(int count)
             {
                 Debug.Assert(count > 0);
-                return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
+                return new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
             }
 
-            public IPartition<TResult> Take(int count)
+            public override Iterator<TResult> Take(int count)
             {
                 Debug.Assert(count > 0);
-                return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, 0, count - 1);
+                return new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, 0, count - 1);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index < (uint)_source.Count)
                 {
@@ -374,7 +431,7 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult? TryGetFirst(out bool found)
+            public override TResult? TryGetFirst(out bool found)
             {
                 if (_source.Count != 0)
                 {
@@ -386,7 +443,7 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult? TryGetLast(out bool found)
+            public override TResult? TryGetLast(out bool found)
             {
                 int len = _source.Count;
                 if (len != 0)
@@ -400,9 +457,9 @@ public IPartition<TResult> Take(int count)
             }
         }
 
-        private sealed partial class SelectIListIterator<TSource, TResult> : IPartition<TResult>
+        private sealed partial class IListSelectIterator<TSource, TResult>
         {
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 int count = _source.Count;
                 if (count == 0)
@@ -416,7 +473,7 @@ public TResult[] ToArray()
                 return results;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 IList<TSource> source = _source;
                 int count = _source.Count;
@@ -435,7 +492,7 @@ private static void Fill(IList<TSource> source, Span<TResult> results, Func<TSou
                 }
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of
                 // the selector, run it provided `onlyIfCheap` is false.
@@ -453,19 +510,19 @@ public int GetCount(bool onlyIfCheap)
                 return count;
             }
 
-            public IPartition<TResult> Skip(int count)
+            public override Iterator<TResult> Skip(int count)
             {
                 Debug.Assert(count > 0);
-                return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
+                return new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, count, int.MaxValue);
             }
 
-            public IPartition<TResult> Take(int count)
+            public override Iterator<TResult> Take(int count)
             {
                 Debug.Assert(count > 0);
-                return new SelectListPartitionIterator<TSource, TResult>(_source, _selector, 0, count - 1);
+                return new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, 0, count - 1);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index < (uint)_source.Count)
                 {
@@ -477,7 +534,7 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult? TryGetFirst(out bool found)
+            public override TResult? TryGetFirst(out bool found)
             {
                 if (_source.Count != 0)
                 {
@@ -489,7 +546,7 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult? TryGetLast(out bool found)
+            public override TResult? TryGetLast(out bool found)
             {
                 int len = _source.Count;
                 if (len != 0)
@@ -504,17 +561,17 @@ public IPartition<TResult> Take(int count)
         }
 
         /// <summary>
-        /// An iterator that maps each item of an <see cref="IPartition{TSource}"/>.
+        /// An iterator that maps each item of an <see cref="Iterator{TSource}"/>.
         /// </summary>
-        /// <typeparam name="TSource">The type of the source partition.</typeparam>
+        /// <typeparam name="TSource">The type of the source elements.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
-        private sealed class SelectIPartitionIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>
+        private sealed class IteratorSelectIterator<TSource, TResult> : Iterator<TResult>
         {
-            private readonly IPartition<TSource> _source;
+            private readonly Iterator<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
             private IEnumerator<TSource>? _enumerator;
 
-            public SelectIPartitionIterator(IPartition<TSource> source, Func<TSource, TResult> selector)
+            public IteratorSelectIterator(Iterator<TSource> source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
@@ -523,7 +580,7 @@ public SelectIPartitionIterator(IPartition<TSource> source, Func<TSource, TResul
             }
 
             public override Iterator<TResult> Clone() =>
-                new SelectIPartitionIterator<TSource, TResult>(_source, _selector);
+                new IteratorSelectIterator<TSource, TResult>(_source, _selector);
 
             public override bool MoveNext()
             {
@@ -560,23 +617,23 @@ public override void Dispose()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectIPartitionIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
+                new IteratorSelectIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
 
-            public IPartition<TResult>? Skip(int count)
+            public override Iterator<TResult>? Skip(int count)
             {
                 Debug.Assert(count > 0);
-                IPartition<TSource>? source = _source.Skip(count);
-                return source is null ? null : new SelectIPartitionIterator<TSource, TResult>(source, _selector);
+                Iterator<TSource>? source = _source.Skip(count);
+                return source is null ? null : new IteratorSelectIterator<TSource, TResult>(source, _selector);
             }
 
-            public IPartition<TResult>? Take(int count)
+            public override Iterator<TResult>? Take(int count)
             {
                 Debug.Assert(count > 0);
-                IPartition<TSource>? source = _source.Take(count);
-                return source is null ? null : new SelectIPartitionIterator<TSource, TResult>(source, _selector);
+                Iterator<TSource>? source = _source.Take(count);
+                return source is null ? null : new IteratorSelectIterator<TSource, TResult>(source, _selector);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 bool sourceFound;
                 TSource? input = _source.TryGetElementAt(index, out sourceFound);
@@ -584,7 +641,7 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
                 return sourceFound ? _selector(input!) : default!;
             }
 
-            public TResult? TryGetFirst(out bool found)
+            public override TResult? TryGetFirst(out bool found)
             {
                 bool sourceFound;
                 TSource? input = _source.TryGetFirst(out sourceFound);
@@ -592,7 +649,7 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
                 return sourceFound ? _selector(input!) : default!;
             }
 
-            public TResult? TryGetLast(out bool found)
+            public override TResult? TryGetLast(out bool found)
             {
                 bool sourceFound;
                 TSource? input = _source.TryGetLast(out sourceFound);
@@ -629,7 +686,7 @@ private TResult[] PreallocatingToArray(int count)
                 return array;
             }
 
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 int count = _source.GetCount(onlyIfCheap: true);
                 return count switch
@@ -640,7 +697,7 @@ public TResult[] ToArray()
                 };
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 int count = _source.GetCount(onlyIfCheap: true);
                 List<TResult> list;
@@ -665,7 +722,7 @@ public List<TResult> ToList()
                 return list;
             }
 
-            private static void Fill(IPartition<TSource> source, Span<TResult> results, Func<TSource, TResult> func)
+            private static void Fill(Iterator<TSource> source, Span<TResult> results, Func<TSource, TResult> func)
             {
                 int index = 0;
                 foreach (TSource item in source)
@@ -677,7 +734,7 @@ private static void Fill(IPartition<TSource> source, Span<TResult> results, Func
                 Debug.Assert(index == results.Length, "All list elements were not initialized.");
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 if (!onlyIfCheap)
                 {
@@ -705,14 +762,14 @@ public int GetCount(bool onlyIfCheap)
         /// <typeparam name="TSource">The type of the source list.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
         [DebuggerDisplay("Count = {Count}")]
-        private sealed class SelectListPartitionIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>
+        private sealed class IListSkipTakeSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly IList<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
             private readonly int _minIndexInclusive;
             private readonly int _maxIndexInclusive;
 
-            public SelectListPartitionIterator(IList<TSource> source, Func<TSource, TResult> selector, int minIndexInclusive, int maxIndexInclusive)
+            public IListSkipTakeSelectIterator(IList<TSource> source, Func<TSource, TResult> selector, int minIndexInclusive, int maxIndexInclusive)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
@@ -725,7 +782,7 @@ public SelectListPartitionIterator(IList<TSource> source, Func<TSource, TResult>
             }
 
             public override Iterator<TResult> Clone() =>
-                new SelectListPartitionIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, _maxIndexInclusive);
+                new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, _maxIndexInclusive);
 
             public override bool MoveNext()
             {
@@ -745,23 +802,23 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectListPartitionIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector), _minIndexInclusive, _maxIndexInclusive);
+                new IListSkipTakeSelectIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector), _minIndexInclusive, _maxIndexInclusive);
 
-            public IPartition<TResult>? Skip(int count)
+            public override Iterator<TResult>? Skip(int count)
             {
                 Debug.Assert(count > 0);
                 int minIndex = _minIndexInclusive + count;
-                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new SelectListPartitionIterator<TSource, TResult>(_source, _selector, minIndex, _maxIndexInclusive);
+                return (uint)minIndex > (uint)_maxIndexInclusive ? null : new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, minIndex, _maxIndexInclusive);
             }
 
-            public IPartition<TResult> Take(int count)
+            public override Iterator<TResult> Take(int count)
             {
                 Debug.Assert(count > 0);
                 int maxIndex = _minIndexInclusive + count - 1;
-                return (uint)maxIndex >= (uint)_maxIndexInclusive ? this : new SelectListPartitionIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, maxIndex);
+                return (uint)maxIndex >= (uint)_maxIndexInclusive ? this : new IListSkipTakeSelectIterator<TSource, TResult>(_source, _selector, _minIndexInclusive, maxIndex);
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if ((uint)index <= (uint)(_maxIndexInclusive - _minIndexInclusive) && index < _source.Count - _minIndexInclusive)
                 {
@@ -773,7 +830,7 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult? TryGetFirst(out bool found)
+            public override TResult? TryGetFirst(out bool found)
             {
                 if (_source.Count > _minIndexInclusive)
                 {
@@ -785,7 +842,7 @@ public IPartition<TResult> Take(int count)
                 return default;
             }
 
-            public TResult? TryGetLast(out bool found)
+            public override TResult? TryGetLast(out bool found)
             {
                 int lastIndex = _source.Count - 1;
                 if (lastIndex >= _minIndexInclusive)
@@ -812,7 +869,7 @@ private int Count
                 }
             }
 
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 int count = Count;
                 if (count == 0)
@@ -826,7 +883,7 @@ public TResult[] ToArray()
                 return array;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 int count = Count;
                 if (count == 0)
@@ -848,7 +905,7 @@ private static void Fill(IList<TSource> source, Span<TResult> destination, Func<
                 }
             }
 
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of
                 // the selector, run it provided `onlyIfCheap` is false.
diff --git a/src/libraries/System.Linq/src/System/Linq/Select.cs b/src/libraries/System.Linq/src/System/Linq/Select.cs
index 3059fa7f0a8e02..916267c1ecaf05 100644
--- a/src/libraries/System.Linq/src/System/Linq/Select.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Select.cs
@@ -37,35 +37,20 @@ public static IEnumerable<TResult> Select<TSource, TResult>(
                         return [];
                     }
 
-                    return new SelectArrayIterator<TSource, TResult>(array, selector);
+                    return new ArraySelectIterator<TSource, TResult>(array, selector);
                 }
 
                 if (source is List<TSource> list)
                 {
-                    return new SelectListIterator<TSource, TResult>(list, selector);
+                    return new ListSelectIterator<TSource, TResult>(list, selector);
                 }
 
-                return new SelectIListIterator<TSource, TResult>(ilist, selector);
+                return new IListSelectIterator<TSource, TResult>(ilist, selector);
             }
 
-            if (source is IPartition<TSource> partition)
-            {
-                IEnumerable<TResult>? result = null;
-                CreateSelectIPartitionIterator(selector, partition, ref result);
-                if (result != null)
-                {
-                    return result;
-                }
-            }
-
-            return new SelectEnumerableIterator<TSource, TResult>(source, selector);
+            return new IEnumerableSelectIterator<TSource, TResult>(source, selector);
         }
 
-#pragma warning disable IDE0060 // https://github.com/dotnet/roslyn-analyzers/issues/6177
-        static partial void CreateSelectIPartitionIterator<TResult, TSource>(
-            Func<TSource, TResult> selector, IPartition<TSource> partition, [NotNull] ref IEnumerable<TResult>? result);
-#pragma warning restore IDE0060
-
         public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
         {
             if (source == null)
@@ -105,13 +90,13 @@ private static IEnumerable<TResult> SelectIterator<TSource, TResult>(IEnumerable
         /// </summary>
         /// <typeparam name="TSource">The type of the source enumerable.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
-        private sealed partial class SelectEnumerableIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class IEnumerableSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
             private IEnumerator<TSource>? _enumerator;
 
-            public SelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, TResult> selector)
+            public IEnumerableSelectIterator(IEnumerable<TSource> source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
@@ -120,7 +105,7 @@ public SelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, TResu
             }
 
             public override Iterator<TResult> Clone() =>
-                new SelectEnumerableIterator<TSource, TResult>(_source, _selector);
+                new IEnumerableSelectIterator<TSource, TResult>(_source, _selector);
 
             public override void Dispose()
             {
@@ -157,7 +142,7 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectEnumerableIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
+                new IEnumerableSelectIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
         }
 
         /// <summary>
@@ -166,12 +151,12 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
         /// <typeparam name="TSource">The type of the source array.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
         [DebuggerDisplay("Count = {CountForDebugger}")]
-        private sealed partial class SelectArrayIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class ArraySelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly TSource[] _source;
             private readonly Func<TSource, TResult> _selector;
 
-            public SelectArrayIterator(TSource[] source, Func<TSource, TResult> selector)
+            public ArraySelectIterator(TSource[] source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
@@ -182,7 +167,7 @@ public SelectArrayIterator(TSource[] source, Func<TSource, TResult> selector)
 
             private int CountForDebugger => _source.Length;
 
-            public override Iterator<TResult> Clone() => new SelectArrayIterator<TSource, TResult>(_source, _selector);
+            public override Iterator<TResult> Clone() => new ArraySelectIterator<TSource, TResult>(_source, _selector);
 
             public override bool MoveNext()
             {
@@ -200,7 +185,7 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectArrayIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
+                new ArraySelectIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
         }
 
         /// <summary>
@@ -209,13 +194,13 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
         /// <typeparam name="TSource">The type of the source list.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
         [DebuggerDisplay("Count = {CountForDebugger}")]
-        private sealed partial class SelectListIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class ListSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly List<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
             private List<TSource>.Enumerator _enumerator;
 
-            public SelectListIterator(List<TSource> source, Func<TSource, TResult> selector)
+            public ListSelectIterator(List<TSource> source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
@@ -225,7 +210,7 @@ public SelectListIterator(List<TSource> source, Func<TSource, TResult> selector)
 
             private int CountForDebugger => _source.Count;
 
-            public override Iterator<TResult> Clone() => new SelectListIterator<TSource, TResult>(_source, _selector);
+            public override Iterator<TResult> Clone() => new ListSelectIterator<TSource, TResult>(_source, _selector);
 
             public override bool MoveNext()
             {
@@ -250,7 +235,7 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectListIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
+                new ListSelectIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
         }
 
         /// <summary>
@@ -259,13 +244,13 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
         /// <typeparam name="TSource">The type of the source list.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
         [DebuggerDisplay("Count = {CountForDebugger}")]
-        private sealed partial class SelectIListIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class IListSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly IList<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
             private IEnumerator<TSource>? _enumerator;
 
-            public SelectIListIterator(IList<TSource> source, Func<TSource, TResult> selector)
+            public IListSelectIterator(IList<TSource> source, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(selector != null);
@@ -275,7 +260,7 @@ public SelectIListIterator(IList<TSource> source, Func<TSource, TResult> selecto
 
             private int CountForDebugger => _source.Count;
 
-            public override Iterator<TResult> Clone() => new SelectIListIterator<TSource, TResult>(_source, _selector);
+            public override Iterator<TResult> Clone() => new IListSelectIterator<TSource, TResult>(_source, _selector);
 
             public override bool MoveNext()
             {
@@ -312,7 +297,7 @@ public override void Dispose()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new SelectIListIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
+                new IListSelectIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/SelectMany.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/SelectMany.SpeedOpt.cs
index 050ae6a4e06b61..ae0bf35ef8f1af 100644
--- a/src/libraries/System.Linq/src/System/Linq/SelectMany.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/SelectMany.SpeedOpt.cs
@@ -7,9 +7,9 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class SelectManySingleSelectorIterator<TSource, TResult> : IIListProvider<TResult>
+        private sealed partial class SelectManySingleSelectorIterator<TSource, TResult>
         {
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 if (onlyIfCheap)
                 {
@@ -29,7 +29,7 @@ public int GetCount(bool onlyIfCheap)
                 return count;
             }
 
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 SegmentedArrayBuilder<TResult>.ScratchBuffer scratch = default;
                 SegmentedArrayBuilder<TResult> builder = new(scratch);
@@ -46,7 +46,7 @@ public TResult[] ToArray()
                 return result;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 var list = new List<TResult>();
 
diff --git a/src/libraries/System.Linq/src/System/Linq/Skip.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Skip.SpeedOpt.cs
index 1596dc0cc7cfe0..74ff73a068242c 100644
--- a/src/libraries/System.Linq/src/System/Linq/Skip.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Skip.SpeedOpt.cs
@@ -9,7 +9,7 @@ public static partial class Enumerable
     {
         private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count) =>
             source is IList<TSource> sourceList ?
-                (IEnumerable<TSource>)new ListPartition<TSource>(sourceList, count, int.MaxValue) :
-                new EnumerablePartition<TSource>(source, count, -1);
+                (IEnumerable<TSource>)new IListSkipTakeIterator<TSource>(sourceList, count, int.MaxValue) :
+                new IEnumerableSkipTakeIterator<TSource>(source, count, -1);
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Skip.cs b/src/libraries/System.Linq/src/System/Linq/Skip.cs
index 3652d1da3e79e8..582fb14f12a47f 100644
--- a/src/libraries/System.Linq/src/System/Linq/Skip.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Skip.cs
@@ -23,17 +23,19 @@ public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> sourc
             {
                 // Return source if not actually skipping, but only if it's a type from here, to avoid
                 // issues if collections are used as keys or otherwise must not be aliased.
-                if (source is Iterator<TSource> || source is IPartition<TSource>)
+                if (source is Iterator<TSource>)
                 {
                     return source;
                 }
 
                 count = 0;
             }
-            else if (source is IPartition<TSource> partition)
+#if !OPTIMIZE_FOR_SIZE
+            else if (source is Iterator<TSource> iterator)
             {
-                return partition.Skip(count) ?? Empty<TSource>();
+                return iterator.Skip(count) ?? Empty<TSource>();
             }
+#endif
 
             return SkipIterator(source, count);
         }
diff --git a/src/libraries/System.Linq/src/System/Linq/Take.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Take.SpeedOpt.cs
index f97c5295f75a78..f761d4a8ab07be 100644
--- a/src/libraries/System.Linq/src/System/Linq/Take.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Take.SpeedOpt.cs
@@ -14,9 +14,9 @@ private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> s
             Debug.Assert(count > 0);
 
             return
-                source is IPartition<TSource> partition ? (partition.Take(count) ?? Empty<TSource>()) :
-                source is IList<TSource> sourceList ? new ListPartition<TSource>(sourceList, 0, count - 1) :
-                new EnumerablePartition<TSource>(source, 0, count - 1);
+                source is Iterator<TSource> iterator ? (iterator.Take(count) ?? Empty<TSource>()) :
+                source is IList<TSource> sourceList ? new IListSkipTakeIterator<TSource>(sourceList, 0, count - 1) :
+                new IEnumerableSkipTakeIterator<TSource>(source, 0, count - 1);
         }
 
         private static IEnumerable<TSource> TakeRangeIterator<TSource>(IEnumerable<TSource> source, int startIndex, int endIndex)
@@ -25,15 +25,15 @@ private static IEnumerable<TSource> TakeRangeIterator<TSource>(IEnumerable<TSour
             Debug.Assert(startIndex >= 0 && startIndex < endIndex);
 
             return
-                source is IPartition<TSource> partition ? TakePartitionRange(partition, startIndex, endIndex) :
-                source is IList<TSource> sourceList ? new ListPartition<TSource>(sourceList, startIndex, endIndex - 1) :
-                new EnumerablePartition<TSource>(source, startIndex, endIndex - 1);
+                source is Iterator<TSource> iterator ? TakeIteratorRange(iterator, startIndex, endIndex) :
+                source is IList<TSource> sourceList ? new IListSkipTakeIterator<TSource>(sourceList, startIndex, endIndex - 1) :
+                new IEnumerableSkipTakeIterator<TSource>(source, startIndex, endIndex - 1);
 
-            static IEnumerable<TSource> TakePartitionRange(IPartition<TSource> partition, int startIndex, int endIndex)
+            static IEnumerable<TSource> TakeIteratorRange(Iterator<TSource> iterator, int startIndex, int endIndex)
             {
-                IPartition<TSource>? source;
+                Iterator<TSource>? source;
                 if (endIndex != 0 &&
-                    (source = partition.Take(endIndex)) is not null &&
+                    (source = iterator.Take(endIndex)) is not null &&
                     (startIndex == 0 || (source = source!.Skip(startIndex)) is not null))
                 {
                     return source;
diff --git a/src/libraries/System.Linq/src/System/Linq/ToCollection.cs b/src/libraries/System.Linq/src/System/Linq/ToCollection.cs
index 043cac8f0038b0..afbf1d4e158a9b 100644
--- a/src/libraries/System.Linq/src/System/Linq/ToCollection.cs
+++ b/src/libraries/System.Linq/src/System/Linq/ToCollection.cs
@@ -16,10 +16,12 @@ public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            if (source is IIListProvider<TSource> arrayProvider)
+#if !OPTIMIZE_FOR_SIZE
+            if (source is Iterator<TSource> iterator)
             {
-                return arrayProvider.ToArray();
+                return iterator.ToArray();
             }
+#endif
 
             if (source is ICollection<TSource> collection)
             {
@@ -57,10 +59,12 @@ public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            if (source is IIListProvider<TSource> listProvider)
+#if !OPTIMIZE_FOR_SIZE
+            if (source is Iterator<TSource> iterator)
             {
-                return listProvider.ToList();
+                return iterator.ToList();
             }
+#endif
 
             return new List<TSource>(source);
         }
diff --git a/src/libraries/System.Linq/src/System/Linq/Union.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Union.SpeedOpt.cs
index 1868e57e817390..0efa8248405b32 100644
--- a/src/libraries/System.Linq/src/System/Linq/Union.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Union.SpeedOpt.cs
@@ -7,7 +7,7 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private abstract partial class UnionIterator<TSource> : IIListProvider<TSource>
+        private abstract partial class UnionIterator<TSource>
         {
             private HashSet<TSource> FillSet()
             {
@@ -24,11 +24,27 @@ private HashSet<TSource> FillSet()
                 }
             }
 
-            public TSource[] ToArray() => HashSetToArray(FillSet());
+            public override TSource[] ToArray() => HashSetToArray(FillSet());
 
-            public List<TSource> ToList() => new List<TSource>(FillSet());
+            public override List<TSource> ToList() => new List<TSource>(FillSet());
 
-            public int GetCount(bool onlyIfCheap) => onlyIfCheap ? -1 : FillSet().Count;
+            public override int GetCount(bool onlyIfCheap) => onlyIfCheap ? -1 : FillSet().Count;
+
+            public override TSource? TryGetFirst(out bool found)
+            {
+                IEnumerable<TSource>? source;
+                for (int i = 0; (source = GetEnumerable(i)) is not null; i++)
+                {
+                    TSource? result = source.TryGetFirst(out found);
+                    if (found)
+                    {
+                        return result;
+                    }
+                }
+
+                found = false;
+                return default;
+            }
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Where.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Where.SpeedOpt.cs
index 5bf0a718088386..d7adb1bd99170e 100644
--- a/src/libraries/System.Linq/src/System/Linq/Where.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Where.SpeedOpt.cs
@@ -8,9 +8,9 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        private sealed partial class WhereEnumerableIterator<TSource> : IPartition<TSource>
+        private sealed partial class IEnumerableWhereIterator<TSource>
         {
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 if (onlyIfCheap)
                 {
@@ -33,7 +33,7 @@ public int GetCount(bool onlyIfCheap)
                 return count;
             }
 
-            public TSource[] ToArray()
+            public override TSource[] ToArray()
             {
                 SegmentedArrayBuilder<TSource>.ScratchBuffer scratch = default;
                 SegmentedArrayBuilder<TSource> builder = new(scratch);
@@ -53,7 +53,7 @@ public TSource[] ToArray()
                 return result;
             }
 
-            public List<TSource> ToList()
+            public override List<TSource> ToList()
             {
                 var list = new List<TSource>();
 
@@ -69,7 +69,7 @@ public List<TSource> ToList()
                 return list;
             }
 
-            public TSource? TryGetFirst(out bool found)
+            public override TSource? TryGetFirst(out bool found)
             {
                 Func<TSource, bool> predicate = _predicate;
 
@@ -86,7 +86,7 @@ public List<TSource> ToList()
                 return default;
             }
 
-            public TSource? TryGetLast(out bool found)
+            public override TSource? TryGetLast(out bool found)
             {
                 using IEnumerator<TSource> e = _source.GetEnumerator();
 
@@ -121,7 +121,7 @@ public List<TSource> ToList()
                 return default;
             }
 
-            public TSource? TryGetElementAt(int index, out bool found)
+            public override TSource? TryGetElementAt(int index, out bool found)
             {
                 if (index >= 0)
                 {
@@ -145,15 +145,11 @@ public List<TSource> ToList()
                 found = false;
                 return default;
             }
-
-            public IPartition<TSource>? Skip(int count) => new EnumerablePartition<TSource>(this, count, -1);
-
-            public IPartition<TSource>? Take(int count) => new EnumerablePartition<TSource>(this, 0, count - 1);
         }
 
-        internal sealed partial class WhereArrayIterator<TSource> : IPartition<TSource>
+        internal sealed partial class ArrayWhereIterator<TSource>
         {
-            public int GetCount(bool onlyIfCheap) => GetCount(onlyIfCheap, _source, _predicate);
+            public override int GetCount(bool onlyIfCheap) => GetCount(onlyIfCheap, _source, _predicate);
 
             public static int GetCount(bool onlyIfCheap, ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
             {
@@ -178,7 +174,7 @@ public static int GetCount(bool onlyIfCheap, ReadOnlySpan<TSource> source, Func<
                 return count;
             }
 
-            public TSource[] ToArray() => ToArray(_source, _predicate);
+            public override TSource[] ToArray() => ToArray(_source, _predicate);
 
             public static TSource[] ToArray(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
             {
@@ -199,7 +195,7 @@ public static TSource[] ToArray(ReadOnlySpan<TSource> source, Func<TSource, bool
                 return result;
             }
 
-            public List<TSource> ToList() => ToList(_source, _predicate);
+            public override List<TSource> ToList() => ToList(_source, _predicate);
 
             public static List<TSource> ToList(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
             {
@@ -216,7 +212,7 @@ public static List<TSource> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 return list;
             }
 
-            public TSource? TryGetFirst(out bool found)
+            public override TSource? TryGetFirst(out bool found)
             {
                 Func<TSource, bool> predicate = _predicate;
 
@@ -233,7 +229,7 @@ public static List<TSource> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 return default;
             }
 
-            public TSource? TryGetLast(out bool found)
+            public override TSource? TryGetLast(out bool found)
             {
                 TSource[] source = _source;
                 Func<TSource, bool> predicate = _predicate;
@@ -251,7 +247,7 @@ public static List<TSource> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 return default;
             }
 
-            public TSource? TryGetElementAt(int index, out bool found)
+            public override TSource? TryGetElementAt(int index, out bool found)
             {
                 if (index >= 0)
                 {
@@ -275,21 +271,17 @@ public static List<TSource> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 found = false;
                 return default;
             }
-
-            public IPartition<TSource>? Skip(int count) => new EnumerablePartition<TSource>(this, count, -1);
-
-            public IPartition<TSource>? Take(int count) => new EnumerablePartition<TSource>(this, 0, count - 1);
         }
 
-        private sealed partial class WhereListIterator<TSource> : Iterator<TSource>, IPartition<TSource>
+        private sealed partial class ListWhereIterator<TSource> : Iterator<TSource>
         {
-            public int GetCount(bool onlyIfCheap) => WhereArrayIterator<TSource>.GetCount(onlyIfCheap, CollectionsMarshal.AsSpan(_source), _predicate);
+            public override int GetCount(bool onlyIfCheap) => ArrayWhereIterator<TSource>.GetCount(onlyIfCheap, CollectionsMarshal.AsSpan(_source), _predicate);
 
-            public TSource[] ToArray() => WhereArrayIterator<TSource>.ToArray(CollectionsMarshal.AsSpan(_source), _predicate);
+            public override TSource[] ToArray() => ArrayWhereIterator<TSource>.ToArray(CollectionsMarshal.AsSpan(_source), _predicate);
 
-            public List<TSource> ToList() => WhereArrayIterator<TSource>.ToList(CollectionsMarshal.AsSpan(_source), _predicate);
+            public override List<TSource> ToList() => ArrayWhereIterator<TSource>.ToList(CollectionsMarshal.AsSpan(_source), _predicate);
 
-            public TSource? TryGetFirst(out bool found)
+            public override TSource? TryGetFirst(out bool found)
             {
                 Func<TSource, bool> predicate = _predicate;
 
@@ -306,7 +298,7 @@ private sealed partial class WhereListIterator<TSource> : Iterator<TSource>, IPa
                 return default;
             }
 
-            public TSource? TryGetLast(out bool found)
+            public override TSource? TryGetLast(out bool found)
             {
                 ReadOnlySpan<TSource> source = CollectionsMarshal.AsSpan(_source);
                 Func<TSource, bool> predicate = _predicate;
@@ -324,7 +316,7 @@ private sealed partial class WhereListIterator<TSource> : Iterator<TSource>, IPa
                 return default;
             }
 
-            public TSource? TryGetElementAt(int index, out bool found)
+            public override TSource? TryGetElementAt(int index, out bool found)
             {
                 if (index >= 0)
                 {
@@ -348,15 +340,11 @@ private sealed partial class WhereListIterator<TSource> : Iterator<TSource>, IPa
                 found = false;
                 return default;
             }
-
-            public IPartition<TSource>? Skip(int count) => new EnumerablePartition<TSource>(this, count, -1);
-
-            public IPartition<TSource>? Take(int count) => new EnumerablePartition<TSource>(this, 0, count - 1);
         }
 
-        private sealed partial class WhereSelectArrayIterator<TSource, TResult> : IPartition<TResult>
+        private sealed partial class ArrayWhereSelectIterator<TSource, TResult>
         {
-            public int GetCount(bool onlyIfCheap) => GetCount(onlyIfCheap, _source, _predicate, _selector);
+            public override int GetCount(bool onlyIfCheap) => GetCount(onlyIfCheap, _source, _predicate, _selector);
 
             public static int GetCount(bool onlyIfCheap, ReadOnlySpan<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
@@ -385,7 +373,7 @@ public static int GetCount(bool onlyIfCheap, ReadOnlySpan<TSource> source, Func<
                 return count;
             }
 
-            public TResult[] ToArray() => ToArray(_source, _predicate, _selector);
+            public override TResult[] ToArray() => ToArray(_source, _predicate, _selector);
 
             public static TResult[] ToArray(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
@@ -406,7 +394,7 @@ public static TResult[] ToArray(ReadOnlySpan<TSource> source, Func<TSource, bool
                 return result;
             }
 
-            public List<TResult> ToList() => ToList(_source, _predicate, _selector);
+            public override List<TResult> ToList() => ToList(_source, _predicate, _selector);
 
             public static List<TResult> ToList(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
@@ -423,7 +411,7 @@ public static List<TResult> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 return list;
             }
 
-            public TResult? TryGetFirst(out bool found) => TryGetFirst(_source, _predicate, _selector, out found);
+            public override TResult? TryGetFirst(out bool found) => TryGetFirst(_source, _predicate, _selector, out found);
 
             public static TResult? TryGetFirst(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector, out bool found)
             {
@@ -440,7 +428,7 @@ public static List<TResult> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 return default;
             }
 
-            public TResult? TryGetLast(out bool found) => TryGetLast(_source, _predicate, _selector, out found);
+            public override TResult? TryGetLast(out bool found) => TryGetLast(_source, _predicate, _selector, out found);
 
             public static TResult? TryGetLast(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector, out bool found)
             {
@@ -457,7 +445,7 @@ public static List<TResult> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 return default;
             }
 
-            public TResult? TryGetElementAt(int index, out bool found) => TryGetElementAt(_source, _predicate, _selector, index, out found);
+            public override TResult? TryGetElementAt(int index, out bool found) => TryGetElementAt(_source, _predicate, _selector, index, out found);
 
             public static TResult? TryGetElementAt(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector, int index, out bool found)
             {
@@ -481,34 +469,26 @@ public static List<TResult> ToList(ReadOnlySpan<TSource> source, Func<TSource, b
                 found = false;
                 return default;
             }
-
-            public IPartition<TResult>? Skip(int count) => new EnumerablePartition<TResult>(this, count, -1);
-
-            public IPartition<TResult>? Take(int count) => new EnumerablePartition<TResult>(this, 0, count - 1);
         }
 
-        private sealed partial class WhereSelectListIterator<TSource, TResult> : IPartition<TResult>
+        private sealed partial class ListWhereSelectIterator<TSource, TResult>
         {
-            public int GetCount(bool onlyIfCheap) => WhereSelectArrayIterator<TSource, TResult>.GetCount(onlyIfCheap, CollectionsMarshal.AsSpan(_source), _predicate, _selector);
-
-            public TResult[] ToArray() => WhereSelectArrayIterator<TSource, TResult>.ToArray(CollectionsMarshal.AsSpan(_source), _predicate, _selector);
+            public override int GetCount(bool onlyIfCheap) => ArrayWhereSelectIterator<TSource, TResult>.GetCount(onlyIfCheap, CollectionsMarshal.AsSpan(_source), _predicate, _selector);
 
-            public List<TResult> ToList() => WhereSelectArrayIterator<TSource, TResult>.ToList(CollectionsMarshal.AsSpan(_source), _predicate, _selector);
+            public override TResult[] ToArray() => ArrayWhereSelectIterator<TSource, TResult>.ToArray(CollectionsMarshal.AsSpan(_source), _predicate, _selector);
 
-            public TResult? TryGetElementAt(int index, out bool found) => WhereSelectArrayIterator<TSource, TResult>.TryGetElementAt(CollectionsMarshal.AsSpan(_source), _predicate, _selector, index, out found);
+            public override List<TResult> ToList() => ArrayWhereSelectIterator<TSource, TResult>.ToList(CollectionsMarshal.AsSpan(_source), _predicate, _selector);
 
-            public TResult? TryGetFirst(out bool found) => WhereSelectArrayIterator<TSource, TResult>.TryGetFirst(CollectionsMarshal.AsSpan(_source), _predicate, _selector, out found);
+            public override TResult? TryGetElementAt(int index, out bool found) => ArrayWhereSelectIterator<TSource, TResult>.TryGetElementAt(CollectionsMarshal.AsSpan(_source), _predicate, _selector, index, out found);
 
-            public TResult? TryGetLast(out bool found) => WhereSelectArrayIterator<TSource, TResult>.TryGetLast(CollectionsMarshal.AsSpan(_source), _predicate, _selector, out found);
+            public override TResult? TryGetFirst(out bool found) => ArrayWhereSelectIterator<TSource, TResult>.TryGetFirst(CollectionsMarshal.AsSpan(_source), _predicate, _selector, out found);
 
-            public IPartition<TResult>? Skip(int count) => new EnumerablePartition<TResult>(this, count, -1);
-
-            public IPartition<TResult>? Take(int count) => new EnumerablePartition<TResult>(this, 0, count - 1);
+            public override TResult? TryGetLast(out bool found) => ArrayWhereSelectIterator<TSource, TResult>.TryGetLast(CollectionsMarshal.AsSpan(_source), _predicate, _selector, out found);
         }
 
-        private sealed partial class WhereSelectEnumerableIterator<TSource, TResult> : IPartition<TResult>
+        private sealed partial class IEnumerableWhereSelectIterator<TSource, TResult>
         {
-            public int GetCount(bool onlyIfCheap)
+            public override int GetCount(bool onlyIfCheap)
             {
                 // In case someone uses Count() to force evaluation of
                 // the selector, run it provided `onlyIfCheap` is false.
@@ -535,7 +515,7 @@ public int GetCount(bool onlyIfCheap)
                 return count;
             }
 
-            public TResult[] ToArray()
+            public override TResult[] ToArray()
             {
                 SegmentedArrayBuilder<TResult>.ScratchBuffer scratch = default;
                 SegmentedArrayBuilder<TResult> builder = new(scratch);
@@ -556,7 +536,7 @@ public TResult[] ToArray()
                 return result;
             }
 
-            public List<TResult> ToList()
+            public override List<TResult> ToList()
             {
                 var list = new List<TResult>();
 
@@ -573,7 +553,7 @@ public List<TResult> ToList()
                 return list;
             }
 
-            public TResult? TryGetFirst(out bool found)
+            public override TResult? TryGetFirst(out bool found)
             {
                 Func<TSource, bool> predicate = _predicate;
 
@@ -590,7 +570,7 @@ public List<TResult> ToList()
                 return default;
             }
 
-            public TResult? TryGetLast(out bool found)
+            public override TResult? TryGetLast(out bool found)
             {
                 using IEnumerator<TSource> e = _source.GetEnumerator();
 
@@ -625,7 +605,7 @@ public List<TResult> ToList()
                 return default;
             }
 
-            public TResult? TryGetElementAt(int index, out bool found)
+            public override TResult? TryGetElementAt(int index, out bool found)
             {
                 if (index >= 0)
                 {
@@ -649,10 +629,6 @@ public List<TResult> ToList()
                 found = false;
                 return default;
             }
-
-            public IPartition<TResult>? Skip(int count) => new EnumerablePartition<TResult>(this, count, -1);
-
-            public IPartition<TResult>? Take(int count) => new EnumerablePartition<TResult>(this, 0, count - 1);
         }
     }
 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Where.cs b/src/libraries/System.Linq/src/System/Linq/Where.cs
index aec6370a330f8e..a3a6656c43bafc 100644
--- a/src/libraries/System.Linq/src/System/Linq/Where.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Where.cs
@@ -33,15 +33,15 @@ public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> sour
                     return [];
                 }
 
-                return new WhereArrayIterator<TSource>(array, predicate);
+                return new ArrayWhereIterator<TSource>(array, predicate);
             }
 
             if (source is List<TSource> list)
             {
-                return new WhereListIterator<TSource>(list, predicate);
+                return new ListWhereIterator<TSource>(list, predicate);
             }
 
-            return new WhereEnumerableIterator<TSource>(source, predicate);
+            return new IEnumerableWhereIterator<TSource>(source, predicate);
         }
 
         public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
@@ -85,13 +85,13 @@ private static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource>
         /// An iterator that filters each item of an <see cref="IEnumerable{TSource}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the source enumerable.</typeparam>
-        private sealed partial class WhereEnumerableIterator<TSource> : Iterator<TSource>
+        private sealed partial class IEnumerableWhereIterator<TSource> : Iterator<TSource>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, bool> _predicate;
             private IEnumerator<TSource>? _enumerator;
 
-            public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate)
+            public IEnumerableWhereIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
@@ -99,7 +99,7 @@ public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool>
                 _predicate = predicate;
             }
 
-            public override Iterator<TSource> Clone() => new WhereEnumerableIterator<TSource>(_source, _predicate);
+            public override Iterator<TSource> Clone() => new IEnumerableWhereIterator<TSource>(_source, _predicate);
 
             public override void Dispose()
             {
@@ -140,22 +140,22 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-                new WhereSelectEnumerableIterator<TSource, TResult>(_source, _predicate, selector);
+                new IEnumerableWhereSelectIterator<TSource, TResult>(_source, _predicate, selector);
 
             public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) =>
-                new WhereEnumerableIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
+                new IEnumerableWhereIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
         }
 
         /// <summary>
         /// An iterator that filters each item of an array.
         /// </summary>
         /// <typeparam name="TSource">The type of the source array.</typeparam>
-        internal sealed partial class WhereArrayIterator<TSource> : Iterator<TSource>
+        internal sealed partial class ArrayWhereIterator<TSource> : Iterator<TSource>
         {
             private readonly TSource[] _source;
             private readonly Func<TSource, bool> _predicate;
 
-            public WhereArrayIterator(TSource[] source, Func<TSource, bool> predicate)
+            public ArrayWhereIterator(TSource[] source, Func<TSource, bool> predicate)
             {
                 Debug.Assert(source != null && source.Length > 0);
                 Debug.Assert(predicate != null);
@@ -164,7 +164,7 @@ public WhereArrayIterator(TSource[] source, Func<TSource, bool> predicate)
             }
 
             public override Iterator<TSource> Clone() =>
-                new WhereArrayIterator<TSource>(_source, _predicate);
+                new ArrayWhereIterator<TSource>(_source, _predicate);
 
             public override bool MoveNext()
             {
@@ -187,23 +187,23 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-                new WhereSelectArrayIterator<TSource, TResult>(_source, _predicate, selector);
+                new ArrayWhereSelectIterator<TSource, TResult>(_source, _predicate, selector);
 
             public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) =>
-                new WhereArrayIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
+                new ArrayWhereIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
         }
 
         /// <summary>
         /// An iterator that filters each item of a <see cref="List{TSource}"/>.
         /// </summary>
         /// <typeparam name="TSource">The type of the source list.</typeparam>
-        private sealed partial class WhereListIterator<TSource> : Iterator<TSource>
+        private sealed partial class ListWhereIterator<TSource> : Iterator<TSource>
         {
             private readonly List<TSource> _source;
             private readonly Func<TSource, bool> _predicate;
             private List<TSource>.Enumerator _enumerator;
 
-            public WhereListIterator(List<TSource> source, Func<TSource, bool> predicate)
+            public ListWhereIterator(List<TSource> source, Func<TSource, bool> predicate)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
@@ -212,7 +212,7 @@ public WhereListIterator(List<TSource> source, Func<TSource, bool> predicate)
             }
 
             public override Iterator<TSource> Clone() =>
-                new WhereListIterator<TSource>(_source, _predicate);
+                new ListWhereIterator<TSource>(_source, _predicate);
 
             public override bool MoveNext()
             {
@@ -241,10 +241,10 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-                new WhereSelectListIterator<TSource, TResult>(_source, _predicate, selector);
+                new ListWhereSelectIterator<TSource, TResult>(_source, _predicate, selector);
 
             public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) =>
-                new WhereListIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
+                new ListWhereIterator<TSource>(_source, CombinePredicates(_predicate, predicate));
         }
 
         /// <summary>
@@ -252,13 +252,13 @@ public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) =>
         /// </summary>
         /// <typeparam name="TSource">The type of the source array.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
-        private sealed partial class WhereSelectArrayIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class ArrayWhereSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly TSource[] _source;
             private readonly Func<TSource, bool> _predicate;
             private readonly Func<TSource, TResult> _selector;
 
-            public WhereSelectArrayIterator(TSource[] source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
+            public ArrayWhereSelectIterator(TSource[] source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null && source.Length > 0);
                 Debug.Assert(predicate != null);
@@ -269,7 +269,7 @@ public WhereSelectArrayIterator(TSource[] source, Func<TSource, bool> predicate,
             }
 
             public override Iterator<TResult> Clone() =>
-                new WhereSelectArrayIterator<TSource, TResult>(_source, _predicate, _selector);
+                new ArrayWhereSelectIterator<TSource, TResult>(_source, _predicate, _selector);
 
             public override bool MoveNext()
             {
@@ -292,7 +292,7 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new WhereSelectArrayIterator<TSource, TResult2>(_source, _predicate, CombineSelectors(_selector, selector));
+                new ArrayWhereSelectIterator<TSource, TResult2>(_source, _predicate, CombineSelectors(_selector, selector));
         }
 
         /// <summary>
@@ -300,14 +300,14 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
         /// </summary>
         /// <typeparam name="TSource">The type of the source list.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
-        private sealed partial class WhereSelectListIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class ListWhereSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly List<TSource> _source;
             private readonly Func<TSource, bool> _predicate;
             private readonly Func<TSource, TResult> _selector;
             private List<TSource>.Enumerator _enumerator;
 
-            public WhereSelectListIterator(List<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
+            public ListWhereSelectIterator(List<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
@@ -318,7 +318,7 @@ public WhereSelectListIterator(List<TSource> source, Func<TSource, bool> predica
             }
 
             public override Iterator<TResult> Clone() =>
-                new WhereSelectListIterator<TSource, TResult>(_source, _predicate, _selector);
+                new ListWhereSelectIterator<TSource, TResult>(_source, _predicate, _selector);
 
             public override bool MoveNext()
             {
@@ -347,7 +347,7 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new WhereSelectListIterator<TSource, TResult2>(_source, _predicate, CombineSelectors(_selector, selector));
+                new ListWhereSelectIterator<TSource, TResult2>(_source, _predicate, CombineSelectors(_selector, selector));
         }
 
         /// <summary>
@@ -355,14 +355,14 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
         /// </summary>
         /// <typeparam name="TSource">The type of the source enumerable.</typeparam>
         /// <typeparam name="TResult">The type of the mapped items.</typeparam>
-        private sealed partial class WhereSelectEnumerableIterator<TSource, TResult> : Iterator<TResult>
+        private sealed partial class IEnumerableWhereSelectIterator<TSource, TResult> : Iterator<TResult>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, bool> _predicate;
             private readonly Func<TSource, TResult> _selector;
             private IEnumerator<TSource>? _enumerator;
 
-            public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
+            public IEnumerableWhereSelectIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
             {
                 Debug.Assert(source != null);
                 Debug.Assert(predicate != null);
@@ -373,7 +373,7 @@ public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource,
             }
 
             public override Iterator<TResult> Clone() =>
-                new WhereSelectEnumerableIterator<TSource, TResult>(_source, _predicate, _selector);
+                new IEnumerableWhereSelectIterator<TSource, TResult>(_source, _predicate, _selector);
 
             public override void Dispose()
             {
@@ -414,7 +414,7 @@ public override bool MoveNext()
             }
 
             public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) =>
-                new WhereSelectEnumerableIterator<TSource, TResult2>(_source, _predicate, CombineSelectors(_selector, selector));
+                new IEnumerableWhereSelectIterator<TSource, TResult2>(_source, _predicate, CombineSelectors(_selector, selector));
         }
     }
 }
diff --git a/src/libraries/System.Linq/tests/AppendPrependTests.cs b/src/libraries/System.Linq/tests/AppendPrependTests.cs
index 9df154f46ff47a..a42f1297bf0930 100644
--- a/src/libraries/System.Linq/tests/AppendPrependTests.cs
+++ b/src/libraries/System.Linq/tests/AppendPrependTests.cs
@@ -263,5 +263,27 @@ public void AppendPrependRunOnce()
             source = NumberRangeGuaranteedNotCollectionType(2, 2).Prepend(1).Prepend(0).Append(4).Append(5).RunOnce();
             Assert.Equal(Enumerable.Range(0, 6), source.ToList());
         }
+
+        [Fact]
+        public void AppendPrepend_First_Last_ElementAt()
+        {
+            Assert.Equal(42, new int[] { 42 }.Append(84).First());
+            Assert.Equal(42, new int[] { 84 }.Prepend(42).First());
+            Assert.Equal(84, new int[] { 42 }.Append(84).Last());
+            Assert.Equal(84, new int[] { 84 }.Prepend(42).Last());
+            Assert.Equal(42, new int[] { 42 }.Append(84).ElementAt(0));
+            Assert.Equal(42, new int[] { 84 }.Prepend(42).ElementAt(0));
+            Assert.Equal(84, new int[] { 42 }.Append(84).ElementAt(1));
+            Assert.Equal(84, new int[] { 84 }.Prepend(42).ElementAt(1));
+
+            Assert.Equal(42, NumberRangeGuaranteedNotCollectionType(42, 1).Append(84).First());
+            Assert.Equal(42, NumberRangeGuaranteedNotCollectionType(84, 1).Prepend(42).First());
+            Assert.Equal(84, NumberRangeGuaranteedNotCollectionType(42, 1).Append(84).Last());
+            Assert.Equal(84, NumberRangeGuaranteedNotCollectionType(84, 1).Prepend(42).Last());
+            Assert.Equal(42, NumberRangeGuaranteedNotCollectionType(42, 1).Append(84).ElementAt(0));
+            Assert.Equal(42, NumberRangeGuaranteedNotCollectionType(84, 1).Prepend(42).ElementAt(0));
+            Assert.Equal(84, NumberRangeGuaranteedNotCollectionType(42, 1).Append(84).ElementAt(1));
+            Assert.Equal(84, NumberRangeGuaranteedNotCollectionType(84, 1).Prepend(42).ElementAt(1));
+        }
     }
 }
diff --git a/src/libraries/System.Linq/tests/ElementAtTests.cs b/src/libraries/System.Linq/tests/ElementAtTests.cs
index 8644a7df0d1e9b..303e44d1411d5a 100644
--- a/src/libraries/System.Linq/tests/ElementAtTests.cs
+++ b/src/libraries/System.Linq/tests/ElementAtTests.cs
@@ -229,14 +229,14 @@ public void NonEmptySource_Consistency_ThrowsIListIndexerException()
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^11));
             // ImmutableArray<T> implements IList<T>. ElementAt calls ImmutableArray<T>'s indexer, which throws IndexOutOfRangeException instead of ArgumentOutOfRangeException.
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(-1));
-            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^11));
+            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^11));
 
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(10));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(new Index(10)));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^0));
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(10));
-            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(10)));
-            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(10)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
         }
 
         [Fact]
@@ -425,17 +425,17 @@ public void EmptySource_Consistency_ThrowsIListIndexerException()
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^1));
             // ImmutableArray<T> implements IList<T>. ElementAt calls ImmutableArray<T>'s indexer, which throws IndexOutOfRangeException instead of ArgumentOutOfRangeException.
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(-1));
-            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^1));
 
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(0));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^0));
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(0));
-            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
 
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(1));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(new Index(1)));
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(1));
-            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(1)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(1)));
         }
 
         [Fact]

From 2fc74f1a5d7d5dde8ba17361e8ae852a145a8075 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Mon, 26 Feb 2024 14:23:42 -0500
Subject: [PATCH 4/7] Rename Partition.SpeedOpt.cs to SkipTake.SpeedOpt.cs

---
 src/libraries/System.Linq/src/System.Linq.csproj                | 2 +-
 .../System/Linq/{Partition.SpeedOpt.cs => SkipTake.SpeedOpt.cs} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/libraries/System.Linq/src/System/Linq/{Partition.SpeedOpt.cs => SkipTake.SpeedOpt.cs} (100%)

diff --git a/src/libraries/System.Linq/src/System.Linq.csproj b/src/libraries/System.Linq/src/System.Linq.csproj
index c9bcf4ac0470a8..7c656e5b50d097 100644
--- a/src/libraries/System.Linq/src/System.Linq.csproj
+++ b/src/libraries/System.Linq/src/System.Linq.csproj
@@ -27,13 +27,13 @@
     <Compile Include="System\Linq\Iterator.SpeedOpt.cs" />
     <Compile Include="System\Linq\Lookup.SpeedOpt.cs" />
     <Compile Include="System\Linq\OrderedEnumerable.SpeedOpt.cs" />
-    <Compile Include="System\Linq\Partition.SpeedOpt.cs" />
     <Compile Include="System\Linq\Range.SpeedOpt.cs" />
     <Compile Include="System\Linq\Repeat.SpeedOpt.cs" />
     <Compile Include="System\Linq\Reverse.SpeedOpt.cs" />
     <Compile Include="System\Linq\Select.SpeedOpt.cs" />
     <Compile Include="System\Linq\SelectMany.SpeedOpt.cs" />
     <Compile Include="System\Linq\Skip.SpeedOpt.cs" />
+    <Compile Include="System\Linq\SkipTake.SpeedOpt.cs" />
     <Compile Include="System\Linq\Take.SpeedOpt.cs" />
     <Compile Include="System\Linq\Union.SpeedOpt.cs" />
     <Compile Include="System\Linq\Where.SpeedOpt.cs" />
diff --git a/src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/SkipTake.SpeedOpt.cs
similarity index 100%
rename from src/libraries/System.Linq/src/System/Linq/Partition.SpeedOpt.cs
rename to src/libraries/System.Linq/src/System/Linq/SkipTake.SpeedOpt.cs

From 7a2baa6050876e44688762932f3317945989be76 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 27 Feb 2024 09:36:09 -0500
Subject: [PATCH 5/7] Address PR feedback, and revert ElementAt bounds check on
 IList

---
 .../System/Linq/DefaultIfEmpty.SpeedOpt.cs    |  6 ++--
 .../System.Linq/src/System/Linq/ElementAt.cs  | 35 ++++++++++---------
 .../src/System/Linq/Grouping.SpeedOpt.cs      |  8 ++---
 .../System.Linq/src/System/Linq/Grouping.cs   |  8 ++---
 .../System.Linq/src/System/Linq/Iterator.cs   |  7 ++--
 .../System.Linq/tests/DefaultIfEmptyTests.cs  | 19 ++++++++++
 .../System.Linq/tests/ElementAtTests.cs       | 12 +++----
 7 files changed, 58 insertions(+), 37 deletions(-)

diff --git a/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs
index e147870eb0d9f7..c89d6797581e9b 100644
--- a/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs
@@ -51,7 +51,7 @@ public override int GetCount(bool onlyIfCheap)
                 }
 
                 found = true;
-                return default;
+                return _default;
             }
 
             public override TSource? TryGetLast(out bool found)
@@ -63,7 +63,7 @@ public override int GetCount(bool onlyIfCheap)
                 }
 
                 found = true;
-                return default;
+                return _default;
             }
 
             public override TSource? TryGetElementAt(int index, out bool found)
@@ -79,7 +79,7 @@ public override int GetCount(bool onlyIfCheap)
                     found = true;
                 }
 
-                return default;
+                return _default;
             }
         }
     }
diff --git a/src/libraries/System.Linq/src/System/Linq/ElementAt.cs b/src/libraries/System.Linq/src/System/Linq/ElementAt.cs
index f2bec12be649aa..0466f7d9694bc5 100644
--- a/src/libraries/System.Linq/src/System/Linq/ElementAt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/ElementAt.cs
@@ -16,7 +16,7 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int i
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
-            TSource? element = TryGetElementAt(source, index, out bool found);
+            TSource? element = TryGetElementAt(source, index, out bool found, guardIListLength: false);
             if (!found)
             {
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
@@ -102,39 +102,42 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, Index
             return element;
         }
 
-        private static TSource? TryGetElementAt<TSource>(this IEnumerable<TSource> source, int index, out bool found) =>
+        private static TSource? TryGetElementAt<TSource>(this IEnumerable<TSource> source, int index, out bool found, bool guardIListLength = true) =>
 #if !OPTIMIZE_FOR_SIZE
             source is Iterator<TSource> iterator ? iterator.TryGetElementAt(index, out found) :
 #endif
-            TryGetElementAtNonIterator(source, index, out found);
+            TryGetElementAtNonIterator(source, index, out found, guardIListLength);
 
-        private static TSource? TryGetElementAtNonIterator<TSource>(IEnumerable<TSource> source, int index, out bool found)
+        private static TSource? TryGetElementAtNonIterator<TSource>(IEnumerable<TSource> source, int index, out bool found, bool guardIListLength = true)
         {
             Debug.Assert(source != null);
 
             if (source is IList<TSource> list)
             {
-                if ((uint)index < (uint)list.Count)
+                // Historically, ElementAt would simply delegate to IList[int] without first checking the bounds.
+                // That in turn meant that whatever exception the IList[int] throws for out-of-bounds access would
+                // propagate, e.g. ImmutableArray throws IndexOutOfRangeException whereas List throws ArgumentOutOfRangeException.
+                // Other uses of this, though, do need to guard, such as ElementAtOrDefault and all the various
+                // internal TryGetElementAt helpers. So, we have a guardIListLength parameter to allow the caller
+                // to specify whether to guard or not.
+                if (!guardIListLength || (uint)index < (uint)list.Count)
                 {
                     found = true;
                     return list[index];
                 }
             }
-            else
+            else if (index >= 0)
             {
-                if (index >= 0)
+                using IEnumerator<TSource> e = source.GetEnumerator();
+                while (e.MoveNext())
                 {
-                    using IEnumerator<TSource> e = source.GetEnumerator();
-                    while (e.MoveNext())
+                    if (index == 0)
                     {
-                        if (index == 0)
-                        {
-                            found = true;
-                            return e.Current;
-                        }
-
-                        index--;
+                        found = true;
+                        return e.Current;
                     }
+
+                    index--;
                 }
             }
 
diff --git a/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs b/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
index 1153dc7ff4977a..d081a09380f956 100644
--- a/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Grouping.SpeedOpt.cs
@@ -7,7 +7,7 @@ namespace System.Linq
 {
     public static partial class Enumerable
     {
-        internal sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult>
+        private sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult>
         {
             public override TResult[] ToArray() =>
                 Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray(_resultSelector);
@@ -19,7 +19,7 @@ public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
         }
 
-        internal sealed partial class GroupByResultIterator<TSource, TKey, TResult>
+        private sealed partial class GroupByResultIterator<TSource, TKey, TResult>
         {
             public override TResult[] ToArray() =>
                 Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray(_resultSelector);
@@ -31,7 +31,7 @@ public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).Count;
         }
 
-        internal sealed partial class GroupByIterator<TSource, TKey, TElement>
+        private sealed partial class GroupByIterator<TSource, TKey, TElement>
         {
             public override IGrouping<TKey, TElement>[] ToArray() =>
                 Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).ToArray();
@@ -43,7 +43,7 @@ public override int GetCount(bool onlyIfCheap) =>
                 onlyIfCheap ? -1 : Lookup<TKey, TElement>.Create(_source, _keySelector, _elementSelector, _comparer).Count;
         }
 
-        internal sealed partial class GroupByIterator<TSource, TKey>
+        private sealed partial class GroupByIterator<TSource, TKey>
         {
             public override IGrouping<TKey, TSource>[] ToArray() =>
                 Lookup<TKey, TSource>.Create(_source, _keySelector, _comparer).ToArray();
diff --git a/src/libraries/System.Linq/src/System/Linq/Grouping.cs b/src/libraries/System.Linq/src/System/Linq/Grouping.cs
index c9b55b85cfad89..b81b7909d4b844 100644
--- a/src/libraries/System.Linq/src/System/Linq/Grouping.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Grouping.cs
@@ -121,7 +121,7 @@ public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(thi
             return new GroupByResultIterator<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
         }
 
-        internal sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult> : Iterator<TResult>
+        private sealed partial class GroupByResultIterator<TSource, TKey, TElement, TResult> : Iterator<TResult>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, TKey> _keySelector;
@@ -179,7 +179,7 @@ public override bool MoveNext()
             }
         }
 
-        internal sealed partial class GroupByResultIterator<TSource, TKey, TResult> : Iterator<TResult>
+        private sealed partial class GroupByResultIterator<TSource, TKey, TResult> : Iterator<TResult>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, TKey> _keySelector;
@@ -235,7 +235,7 @@ public override bool MoveNext()
             }
         }
 
-        internal sealed partial class GroupByIterator<TSource, TKey, TElement> : Iterator<IGrouping<TKey, TElement>>
+        private sealed partial class GroupByIterator<TSource, TKey, TElement> : Iterator<IGrouping<TKey, TElement>>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, TKey> _keySelector;
@@ -290,7 +290,7 @@ public override bool MoveNext()
             }
         }
 
-        internal sealed partial class GroupByIterator<TSource, TKey> : Iterator<IGrouping<TKey, TSource>>
+        private sealed partial class GroupByIterator<TSource, TKey> : Iterator<IGrouping<TKey, TSource>>
         {
             private readonly IEnumerable<TSource> _source;
             private readonly Func<TSource, TKey> _keySelector;
diff --git a/src/libraries/System.Linq/src/System/Linq/Iterator.cs b/src/libraries/System.Linq/src/System/Linq/Iterator.cs
index 933868212428bf..4738d2343069eb 100644
--- a/src/libraries/System.Linq/src/System/Linq/Iterator.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Iterator.cs
@@ -88,13 +88,12 @@ public IEnumerator<TSource> GetEnumerator()
             /// <typeparam name="TResult">The type of the mapped items.</typeparam>
             /// <param name="selector">The selector used to map each item.</param>
             public virtual IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) =>
-                new
 #if OPTIMIZE_FOR_SIZE
-                IEnumerableSelectIterator
+                new IEnumerableSelectIterator<TSource, TResult>(this, selector);
 #else
-                IteratorSelectIterator
+                new IteratorSelectIterator<TSource, TResult>(this, selector);
 #endif
-                <TSource, TResult>(this, selector);
+
 
             /// <summary>
             /// Returns an enumerable that filters each item in this iterator based on a predicate.
diff --git a/src/libraries/System.Linq/tests/DefaultIfEmptyTests.cs b/src/libraries/System.Linq/tests/DefaultIfEmptyTests.cs
index b4e9e13f804240..843d2a7d9e425f 100644
--- a/src/libraries/System.Linq/tests/DefaultIfEmptyTests.cs
+++ b/src/libraries/System.Linq/tests/DefaultIfEmptyTests.cs
@@ -105,5 +105,24 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void First_Last_ElementAt()
+        {
+            IEnumerable<int> nonEmpty = Enumerable.Range(1, 3);
+            Assert.Equal(1, nonEmpty.First());
+            Assert.Equal(3, nonEmpty.Last());
+            Assert.Equal(1, nonEmpty.ElementAt(0));
+            Assert.Equal(2, nonEmpty.ElementAt(1));
+            Assert.Equal(3, nonEmpty.ElementAt(2));
+            Assert.Throws<ArgumentOutOfRangeException>(() => nonEmpty.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => nonEmpty.ElementAt(4));
+
+            IEnumerable<int> empty = Enumerable.Empty<int>();
+            Assert.Equal(42, empty.DefaultIfEmpty(42).First());
+            Assert.Equal(42, empty.DefaultIfEmpty(42).Last());
+            Assert.Equal(42, empty.DefaultIfEmpty(42).ElementAt(0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => empty.DefaultIfEmpty(42).ElementAt(1));
+        }
     }
 }
diff --git a/src/libraries/System.Linq/tests/ElementAtTests.cs b/src/libraries/System.Linq/tests/ElementAtTests.cs
index 303e44d1411d5a..8644a7df0d1e9b 100644
--- a/src/libraries/System.Linq/tests/ElementAtTests.cs
+++ b/src/libraries/System.Linq/tests/ElementAtTests.cs
@@ -229,14 +229,14 @@ public void NonEmptySource_Consistency_ThrowsIListIndexerException()
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^11));
             // ImmutableArray<T> implements IList<T>. ElementAt calls ImmutableArray<T>'s indexer, which throws IndexOutOfRangeException instead of ArgumentOutOfRangeException.
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(-1));
-            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^11));
+            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^11));
 
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(10));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(new Index(10)));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^0));
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(10));
-            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(10)));
-            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
+            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(10)));
+            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
         }
 
         [Fact]
@@ -425,17 +425,17 @@ public void EmptySource_Consistency_ThrowsIListIndexerException()
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^1));
             // ImmutableArray<T> implements IList<T>. ElementAt calls ImmutableArray<T>'s indexer, which throws IndexOutOfRangeException instead of ArgumentOutOfRangeException.
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(-1));
-            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^1));
+            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^1));
 
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(0));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(^0));
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(0));
-            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
+            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(^0));
 
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(1));
             Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(new Index(1)));
             Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(1));
-            Assert.Throws<ArgumentOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(1)));
+            Assert.Throws<IndexOutOfRangeException>(() => ImmutableArray.Create(source).ElementAt(new Index(1)));
         }
 
         [Fact]

From 1b25bee5f6e688e2b61fc8060c2ee2cd058a6ade Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 27 Feb 2024 14:02:42 -0500
Subject: [PATCH 6/7] Fill some code coverage test holes

---
 .../System.Linq/tests/AggregateByTests.cs     | 22 +++++++--
 src/libraries/System.Linq/tests/ChunkTests.cs |  6 +++
 .../System.Linq/tests/ConcatTests.cs          | 49 +++++++++++++++++++
 .../System.Linq/tests/DistinctTests.cs        |  6 +++
 .../System.Linq/tests/GroupByTests.cs         | 25 +++++++++-
 src/libraries/System.Linq/tests/IndexTests.cs |  6 +++
 src/libraries/System.Linq/tests/MaxTests.cs   |  9 ++++
 src/libraries/System.Linq/tests/MinTests.cs   | 13 +++++
 src/libraries/System.Linq/tests/OrderTests.cs | 16 ++++++
 src/libraries/System.Linq/tests/RangeTests.cs |  3 ++
 .../System.Linq/tests/RepeatTests.cs          |  3 ++
 .../System.Linq/tests/SequenceEqualTests.cs   | 29 ++++++++++-
 .../System.Linq/tests/SkipLastTests.cs        |  6 +++
 .../System.Linq/tests/SkipWhileTests.cs       |  9 +++-
 .../System.Linq/tests/TakeLastTests.cs        |  6 +++
 src/libraries/System.Linq/tests/TakeTests.cs  | 33 +++++++++++++
 .../System.Linq/tests/TakeWhileTests.cs       |  8 ++-
 .../System.Linq/tests/ToLookupTests.cs        | 33 +++++++++++--
 src/libraries/System.Linq/tests/WhereTests.cs | 44 +++++++++++++++++
 19 files changed, 314 insertions(+), 12 deletions(-)

diff --git a/src/libraries/System.Linq/tests/AggregateByTests.cs b/src/libraries/System.Linq/tests/AggregateByTests.cs
index daae145f775508..6232ce24a6df49 100644
--- a/src/libraries/System.Linq/tests/AggregateByTests.cs
+++ b/src/libraries/System.Linq/tests/AggregateByTests.cs
@@ -8,6 +8,16 @@ namespace System.Linq.Tests
 {
     public class AggregateByTests : EnumerableTests
     {
+        [Fact]
+        public void Empty()
+        {
+            Assert.All(IdentityTransforms<int>(), transform =>
+            {
+                Assert.Equal(Enumerable.Empty<KeyValuePair<int, int>>(), transform(Enumerable.Empty<int>()).AggregateBy(i => i, i => i, (a, i) => a + i));
+                Assert.Equal(Enumerable.Empty<KeyValuePair<int, int>>(), transform(Enumerable.Empty<int>()).AggregateBy(i => i, 0, (a, i) => a + i));
+            });
+        }
+
         [Fact]
         public void AggregateBy_SourceNull_ThrowsArgumentNullException()
         {
@@ -15,22 +25,26 @@ public void AggregateBy_SourceNull_ThrowsArgumentNullException()
 
             AssertExtensions.Throws<ArgumentNullException>("source", () => first.AggregateBy(x => x, string.Empty, (x, y) => x + y));
             AssertExtensions.Throws<ArgumentNullException>("source", () => first.AggregateBy(x => x, string.Empty, (x, y) => x + y, new AnagramEqualityComparer()));
+            AssertExtensions.Throws<ArgumentNullException>("source", () => first.AggregateBy(x => x, x => x, (x, y) => x + y));
+            AssertExtensions.Throws<ArgumentNullException>("source", () => first.AggregateBy(x => x, x => x, (x, y) => x + y, new AnagramEqualityComparer()));
         }
 
         [Fact]
         public void AggregateBy_KeySelectorNull_ThrowsArgumentNullException()
         {
-            string[] source = { };
+            string[] source = ["test"];
             Func<string, string> keySelector = null;
 
             AssertExtensions.Throws<ArgumentNullException>("keySelector", () => source.AggregateBy(keySelector, string.Empty, (x, y) => x + y));
             AssertExtensions.Throws<ArgumentNullException>("keySelector", () => source.AggregateBy(keySelector, string.Empty, (x, y) => x + y, new AnagramEqualityComparer()));
+            AssertExtensions.Throws<ArgumentNullException>("keySelector", () => source.AggregateBy(keySelector, x => x, (x, y) => x + y));
+            AssertExtensions.Throws<ArgumentNullException>("keySelector", () => source.AggregateBy(keySelector, x => x, (x, y) => x + y, new AnagramEqualityComparer()));
         }
 
         [Fact]
         public void AggregateBy_SeedSelectorNull_ThrowsArgumentNullException()
         {
-            string[] source = { };
+            string[] source = ["test"];
             Func<string, string> seedSelector = null;
 
             AssertExtensions.Throws<ArgumentNullException>("seedSelector", () => source.AggregateBy(x => x, seedSelector, (x, y) => x + y));
@@ -40,11 +54,13 @@ public void AggregateBy_SeedSelectorNull_ThrowsArgumentNullException()
         [Fact]
         public void AggregateBy_FuncNull_ThrowsArgumentNullException()
         {
-            string[] source = { };
+            string[] source = ["test"];
             Func<string, string, string> func = null;
 
             AssertExtensions.Throws<ArgumentNullException>("func", () => source.AggregateBy(x => x, string.Empty, func));
             AssertExtensions.Throws<ArgumentNullException>("func", () => source.AggregateBy(x => x, string.Empty, func, new AnagramEqualityComparer()));
+            AssertExtensions.Throws<ArgumentNullException>("func", () => source.AggregateBy(x => x, x => x, func));
+            AssertExtensions.Throws<ArgumentNullException>("func", () => source.AggregateBy(x => x, x => x, func, new AnagramEqualityComparer()));
         }
 
         [Fact]
diff --git a/src/libraries/System.Linq/tests/ChunkTests.cs b/src/libraries/System.Linq/tests/ChunkTests.cs
index ee348604192792..f8cfc4de6b854e 100644
--- a/src/libraries/System.Linq/tests/ChunkTests.cs
+++ b/src/libraries/System.Linq/tests/ChunkTests.cs
@@ -7,6 +7,12 @@ namespace System.Linq.Tests
 {
     public class ChunkTests : EnumerableTests
     {
+        [Fact]
+        public void Empty()
+        {
+            Assert.Equal(Enumerable.Empty<int[]>(), Enumerable.Empty<int>().Chunk(4));
+        }
+
         [Fact]
         public void ThrowsOnNullSource()
         {
diff --git a/src/libraries/System.Linq/tests/ConcatTests.cs b/src/libraries/System.Linq/tests/ConcatTests.cs
index 6209d846ff2438..0435bba5d7f05f 100644
--- a/src/libraries/System.Linq/tests/ConcatTests.cs
+++ b/src/libraries/System.Linq/tests/ConcatTests.cs
@@ -83,6 +83,55 @@ public void VerifyEquals(IEnumerable<int> expected, IEnumerable<int> actual)
             VerifyEqualsWorker(expected, actual);
         }
 
+        [Theory]
+        [MemberData(nameof(ArraySourcesData))]
+        [MemberData(nameof(SelectArraySourcesData))]
+        [MemberData(nameof(EnumerableSourcesData))]
+        [MemberData(nameof(NonCollectionSourcesData))]
+        [MemberData(nameof(ListSourcesData))]
+        [MemberData(nameof(ConcatOfConcatsData))]
+        [MemberData(nameof(ConcatWithSelfData))]
+        [MemberData(nameof(ChainedCollectionConcatData))]
+        [MemberData(nameof(AppendedPrependedConcatAlternationsData))]
+        public void First_Last_ElementAt(IEnumerable<int> _, IEnumerable<int> actual)
+        {
+            int count = actual.Count();
+            if (count == 0)
+            {
+                Assert.Throws<InvalidOperationException>(() => actual.First());
+                Assert.Throws<InvalidOperationException>(() => actual.Last());
+                Assert.Throws<ArgumentOutOfRangeException>(() => actual.ElementAt(0));
+            }
+            else
+            {
+                int first = actual.First();
+                int last = actual.Last();
+                int elementAt = actual.ElementAt(count / 2);
+
+                int enumeratedFirst = 0, enumeratedLast = 0, enumeratedElementAt = 0;
+                int i = 0;
+                foreach (int item in actual)
+                {
+                    if (i == 0)
+                    {
+                        enumeratedFirst = item;
+                    }
+
+                    if (i == count / 2)
+                    {
+                        enumeratedElementAt = item;
+                    }
+
+                    enumeratedLast = item;
+                    i++;
+                }
+
+                Assert.Equal(enumeratedFirst, first);
+                Assert.Equal(enumeratedLast, last);
+                Assert.Equal(enumeratedElementAt, elementAt);
+            }
+        }
+
         private static void VerifyEqualsWorker<T>(IEnumerable<T> expected, IEnumerable<T> actual)
         {
             // Returns a list of functions that, when applied to enumerable, should return
diff --git a/src/libraries/System.Linq/tests/DistinctTests.cs b/src/libraries/System.Linq/tests/DistinctTests.cs
index 7408e96ddb38ce..e9de987ee0481d 100644
--- a/src/libraries/System.Linq/tests/DistinctTests.cs
+++ b/src/libraries/System.Linq/tests/DistinctTests.cs
@@ -303,6 +303,12 @@ public static void DistinctBy_RunOnce_HasExpectedOutput<TSource, TKey>(IEnumerab
 
         public static IEnumerable<object[]> DistinctBy_TestData()
         {
+            yield return WrapArgs(
+                source: Array.Empty<int>(),
+                keySelector: x => x,
+                comparer: null,
+                expected: Enumerable.Empty<int>());
+
             yield return WrapArgs(
                 source: Enumerable.Range(0, 10),
                 keySelector: x => x,
diff --git a/src/libraries/System.Linq/tests/GroupByTests.cs b/src/libraries/System.Linq/tests/GroupByTests.cs
index 4b8967a28a82e7..5036ebe9b02698 100644
--- a/src/libraries/System.Linq/tests/GroupByTests.cs
+++ b/src/libraries/System.Linq/tests/GroupByTests.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Reflection;
 using Xunit;
 
@@ -864,5 +863,29 @@ public static void GroupingKeyIsPublic()
             PropertyInfo key = grouptype.GetProperty("Key", BindingFlags.Instance | BindingFlags.Public);
             Assert.NotNull(key);
         }
+
+        [Fact]
+        public void MultipleIterationsOfSameEnumerable()
+        {
+            foreach (IEnumerable<IGrouping<int, int>> e1 in new[] { Enumerable.Range(0, 10).GroupBy(i => i), Enumerable.Range(0, 10).GroupBy(i => i, i => i) })
+            {
+                for (int trial = 0; trial < 3; trial++)
+                {
+                    int count = 0;
+                    foreach (IGrouping<int, int> g in e1) count++;
+                    Assert.Equal(10, count);
+                }
+            }
+
+            foreach (IEnumerable<int> e2 in new[] { Enumerable.Range(0, 10).GroupBy(i => i, (i, e) => i), Enumerable.Range(0, 10).GroupBy(i => i, i => i, (i, e) => i) })
+            {
+                for (int trial = 0; trial < 3; trial++)
+                {
+                    int count = 0;
+                    foreach (int i in e2) count++;
+                    Assert.Equal(10, count);
+                }
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Linq/tests/IndexTests.cs b/src/libraries/System.Linq/tests/IndexTests.cs
index 4b08820fe0e30c..0742569f787d40 100644
--- a/src/libraries/System.Linq/tests/IndexTests.cs
+++ b/src/libraries/System.Linq/tests/IndexTests.cs
@@ -8,6 +8,12 @@ namespace System.Linq.Tests
 {
     public class IndexTests : EnumerableTests
     {
+        [Fact]
+        public void Empty()
+        {
+            Assert.Empty(Enumerable.Empty<int>().Index());
+        }
+
         [Fact]
         public void Index_SourceIsNull_ArgumentNullExceptionThrown()
         {
diff --git a/src/libraries/System.Linq/tests/MaxTests.cs b/src/libraries/System.Linq/tests/MaxTests.cs
index a1509855091d11..bb70a14d684c72 100644
--- a/src/libraries/System.Linq/tests/MaxTests.cs
+++ b/src/libraries/System.Linq/tests/MaxTests.cs
@@ -251,6 +251,8 @@ public void Max_Float_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<float>().Max());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<float>().Max(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<float>()).Max());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<float>()).Max(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<float>().Max());
             Assert.Throws<InvalidOperationException>(() => new List<float>().Max());
         }
@@ -331,6 +333,8 @@ public void Max_Double_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<double>().Max());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<double>().Max(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<double>()).Max());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<double>()).Max(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<double>().Max());
             Assert.Throws<InvalidOperationException>(() => new List<double>().Max());
         }
@@ -397,6 +401,8 @@ public void Max_Decimal_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<decimal>().Max());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<decimal>().Max(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<decimal>()).Max());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<decimal>()).Max(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<decimal>().Max());
             Assert.Throws<InvalidOperationException>(() => new List<decimal>().Max(x => x));
         }
@@ -622,6 +628,8 @@ public void Max_DateTime_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<DateTime>().Max());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<DateTime>().Max(i => i));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<DateTime>()).Max());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<DateTime>()).Max(i => i));
         }
 
         public static IEnumerable<object[]> Max_String_TestData()
@@ -888,6 +896,7 @@ public void Max_String_WithSelectorAccessingProperty()
         public void Max_Boolean_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<bool>().Max());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<bool>()).Max());
         }
 
         [Fact]
diff --git a/src/libraries/System.Linq/tests/MinTests.cs b/src/libraries/System.Linq/tests/MinTests.cs
index feca6994d066d6..0cc72fa43a1001 100644
--- a/src/libraries/System.Linq/tests/MinTests.cs
+++ b/src/libraries/System.Linq/tests/MinTests.cs
@@ -136,6 +136,8 @@ public void Min_Int_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().Min());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<int>().Min(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<int>()).Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<int>()).Min(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<int>().Min());
             Assert.Throws<InvalidOperationException>(() => new List<int>().Min());
         }
@@ -182,6 +184,8 @@ public void Min_Long_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<long>().Min());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<long>().Min(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<long>()).Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<long>()).Min(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<long>().Min());
             Assert.Throws<InvalidOperationException>(() => new List<long>().Min());
         }
@@ -250,6 +254,8 @@ public void Min_Float_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<float>().Min());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<float>().Min(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<float>()).Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<float>()).Min(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<float>().Min());
             Assert.Throws<InvalidOperationException>(() => new List<float>().Min());
         }
@@ -316,6 +322,8 @@ public void Min_Double_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<double>().Min());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<double>().Min(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<double>()).Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<double>()).Min(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<double>().Min());
             Assert.Throws<InvalidOperationException>(() => new List<double>().Min());
         }
@@ -355,6 +363,8 @@ public void Min_Decimal_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<decimal>().Min());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<decimal>().Min(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<decimal>()).Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<decimal>()).Min(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<decimal>().Min());
             Assert.Throws<InvalidOperationException>(() => new List<decimal>().Min());
         }
@@ -595,6 +605,8 @@ public void Min_DateTime_EmptySource_ThrowsInvalidOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<DateTime>().Min());
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<DateTime>().Min(x => x));
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<DateTime>()).Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<DateTime>()).Min(x => x));
             Assert.Throws<InvalidOperationException>(() => Array.Empty<DateTime>().Min());
             Assert.Throws<InvalidOperationException>(() => new List<DateTime>().Min());
         }
@@ -858,6 +870,7 @@ public void Min_String_NullSelector_ThrowsArgumentNullException()
         public void Min_Bool_EmptySource_ThrowsInvalodOperationException()
         {
             Assert.Throws<InvalidOperationException>(() => Enumerable.Empty<bool>().Min());
+            Assert.Throws<InvalidOperationException>(() => ForceNotCollection(Enumerable.Empty<bool>()).Min());
         }
 
         [Fact]
diff --git a/src/libraries/System.Linq/tests/OrderTests.cs b/src/libraries/System.Linq/tests/OrderTests.cs
index ed2dd9bfc8765e..dee76efe73823d 100644
--- a/src/libraries/System.Linq/tests/OrderTests.cs
+++ b/src/libraries/System.Linq/tests/OrderTests.cs
@@ -196,6 +196,9 @@ public void FirstOnOrdered()
         {
             Assert.Equal(0, Enumerable.Range(0, 10).Shuffle().Order().First());
             Assert.Equal(9, Enumerable.Range(0, 10).Shuffle().OrderDescending().First());
+
+            Assert.Equal(0, ForceNotCollection(Enumerable.Range(0, 10).Shuffle()).Order().First());
+            Assert.Equal(9, ForceNotCollection(Enumerable.Range(0, 10).Shuffle()).OrderDescending().First());
         }
 
         [Fact]
@@ -281,6 +284,9 @@ public void LastOnOrdered()
         {
             Assert.Equal(9, Enumerable.Range(0, 10).Shuffle().Order().Last());
             Assert.Equal(0, Enumerable.Range(0, 10).Shuffle().OrderDescending().Last());
+
+            Assert.Equal(9, ForceNotCollection(Enumerable.Range(0, 10).Shuffle()).Order().Last());
+            Assert.Equal(0, ForceNotCollection(Enumerable.Range(0, 10).Shuffle()).OrderDescending().Last());
         }
 
         [Fact]
@@ -307,6 +313,16 @@ public void LastOrDefaultOnOrdered()
             Assert.Equal(0, Enumerable.Empty<int>().Order().LastOrDefault());
         }
 
+        [Fact]
+        public void ElementAtOnOrdered()
+        {
+            Assert.Equal(4, Enumerable.Range(0, 10).Shuffle().Order().ElementAt(4));
+            Assert.Equal(5, Enumerable.Range(0, 10).Shuffle().OrderDescending().ElementAt(4));
+
+            Assert.Equal(4, ForceNotCollection(Enumerable.Range(0, 10).Shuffle()).Order().ElementAt(4));
+            Assert.Equal(5, ForceNotCollection(Enumerable.Range(0, 10).Shuffle()).OrderDescending().ElementAt(4));
+        }
+
         [Fact]
         public void EnumeratorDoesntContinue()
         {
diff --git a/src/libraries/System.Linq/tests/RangeTests.cs b/src/libraries/System.Linq/tests/RangeTests.cs
index 8421a66ba890c9..2e331cfee7ecd7 100644
--- a/src/libraries/System.Linq/tests/RangeTests.cs
+++ b/src/libraries/System.Linq/tests/RangeTests.cs
@@ -243,6 +243,7 @@ static void Validate(IEnumerable<int> e, int[] expected)
                 Assert.Throws<NotSupportedException>(() => list.Insert(0, 42));
                 Assert.Throws<NotSupportedException>(() => list.Clear());
                 Assert.Throws<NotSupportedException>(() => list.Remove(42));
+                Assert.Throws<NotSupportedException>(() => list.RemoveAt(0));
                 Assert.Throws<NotSupportedException>(() => list[0] = 42);
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => list[-1]);
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => list[expected.Length]);
@@ -255,6 +256,8 @@ static void Validate(IEnumerable<int> e, int[] expected)
 
                 Assert.False(list.Contains(expected[0] - 1));
                 Assert.False(list.Contains(expected[^1] + 1));
+                Assert.Equal(-1, list.IndexOf(expected[0] - 1));
+                Assert.Equal(-1, list.IndexOf(expected[^1] + 1));
                 Assert.All(expected, i => Assert.True(list.Contains(i)));
                 Assert.All(expected, i => Assert.Equal(Array.IndexOf(expected, i), list.IndexOf(i)));
                 for (int i = 0; i < expected.Length; i++)
diff --git a/src/libraries/System.Linq/tests/RepeatTests.cs b/src/libraries/System.Linq/tests/RepeatTests.cs
index 625dff376de311..df8eebda35691e 100644
--- a/src/libraries/System.Linq/tests/RepeatTests.cs
+++ b/src/libraries/System.Linq/tests/RepeatTests.cs
@@ -255,6 +255,7 @@ static void Validate(IEnumerable<int> e, int[] expected)
                 Assert.Throws<NotSupportedException>(() => list.Insert(0, 42));
                 Assert.Throws<NotSupportedException>(() => list.Clear());
                 Assert.Throws<NotSupportedException>(() => list.Remove(42));
+                Assert.Throws<NotSupportedException>(() => list.RemoveAt(0));
                 Assert.Throws<NotSupportedException>(() => list[0] = 42);
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => list[-1]);
                 AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => list[expected.Length]);
@@ -267,6 +268,8 @@ static void Validate(IEnumerable<int> e, int[] expected)
 
                 Assert.False(list.Contains(expected[0] - 1));
                 Assert.False(list.Contains(expected[^1] + 1));
+                Assert.Equal(-1, list.IndexOf(expected[0] - 1));
+                Assert.Equal(-1, list.IndexOf(expected[^1] + 1));
                 Assert.All(expected, i => Assert.True(list.Contains(i)));
                 Assert.All(expected, i => Assert.Equal(Array.IndexOf(expected, i), list.IndexOf(i)));
                 for (int i = 0; i < expected.Length; i++)
diff --git a/src/libraries/System.Linq/tests/SequenceEqualTests.cs b/src/libraries/System.Linq/tests/SequenceEqualTests.cs
index 380916550efd60..7393d18947aa8f 100644
--- a/src/libraries/System.Linq/tests/SequenceEqualTests.cs
+++ b/src/libraries/System.Linq/tests/SequenceEqualTests.cs
@@ -1,8 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -246,5 +245,31 @@ public void ByteArrays_SpecialCasedButExpectedBehavior()
                 }
             }
         }
+
+        [Fact]
+        public void ICollectionsCompareCorrectly()
+        {
+            Assert.True(new TestCollection<int>([]).SequenceEqual(new TestCollection<int>([])));
+            Assert.True(new TestCollection<int>([1]).SequenceEqual(new TestCollection<int>([1])));
+            Assert.True(new TestCollection<int>([1, 2, 3]).SequenceEqual(new TestCollection<int>([1, 2, 3])));
+
+            Assert.False(new TestCollection<int>([1, 2, 3, 4]).SequenceEqual(new TestCollection<int>([1, 2, 3])));
+            Assert.False(new TestCollection<int>([1, 2, 3]).SequenceEqual(new TestCollection<int>([1, 2, 3, 4])));
+            Assert.False(new TestCollection<int>([1, 2, 3]).SequenceEqual(new TestCollection<int>([1, 2, 4])));
+            Assert.False(new TestCollection<int>([-1, 2, 3]).SequenceEqual(new TestCollection<int>([-2, 2, 3])));
+        }
+
+        [Fact]
+        public void IListsCompareCorrectly()
+        {
+            Assert.True(new ReadOnlyCollection<int>([]).SequenceEqual(new ReadOnlyCollection<int>([])));
+            Assert.True(new ReadOnlyCollection<int>([1]).SequenceEqual(new ReadOnlyCollection<int>([1])));
+            Assert.True(new ReadOnlyCollection<int>([1, 2, 3]).SequenceEqual(new ReadOnlyCollection<int>([1, 2, 3])));
+
+            Assert.False(new ReadOnlyCollection<int>([1, 2, 3, 4]).SequenceEqual(new ReadOnlyCollection<int>([1, 2, 3])));
+            Assert.False(new ReadOnlyCollection<int>([1, 2, 3]).SequenceEqual(new ReadOnlyCollection<int>([1, 2, 3, 4])));
+            Assert.False(new ReadOnlyCollection<int>([1, 2, 3]).SequenceEqual(new ReadOnlyCollection<int>([1, 2, 4])));
+            Assert.False(new ReadOnlyCollection<int>([-1, 2, 3]).SequenceEqual(new ReadOnlyCollection<int>([-2, 2, 3])));
+        }
     }
 }
diff --git a/src/libraries/System.Linq/tests/SkipLastTests.cs b/src/libraries/System.Linq/tests/SkipLastTests.cs
index fe9652a875e9d9..c4770410870d47 100644
--- a/src/libraries/System.Linq/tests/SkipLastTests.cs
+++ b/src/libraries/System.Linq/tests/SkipLastTests.cs
@@ -9,6 +9,12 @@ namespace System.Linq.Tests
 {
     public class SkipLastTests : EnumerableTests
     {
+        [Fact]
+        public void SkipLastThrowsOnNull()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).SkipLast(10));
+        }
+
         [Theory]
         [MemberData(nameof(EnumerableData), MemberType = typeof(SkipTakeData))]
         public void SkipLast(IEnumerable<int> source, int count)
diff --git a/src/libraries/System.Linq/tests/SkipWhileTests.cs b/src/libraries/System.Linq/tests/SkipWhileTests.cs
index 26281efc5f862a..75a90967042887 100644
--- a/src/libraries/System.Linq/tests/SkipWhileTests.cs
+++ b/src/libraries/System.Linq/tests/SkipWhileTests.cs
@@ -1,15 +1,20 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections;
 using System.Collections.Generic;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace System.Linq.Tests
 {
     public class SkipWhileTests : EnumerableTests
     {
+        [Fact]
+        public void Empty()
+        {
+            Assert.Equal(Enumerable.Empty<int>(), Enumerable.Empty<int>().SkipWhile(i => i < 40));
+            Assert.Equal(Enumerable.Empty<int>(), Enumerable.Empty<int>().SkipWhile((i, index) => i < 40));
+        }
+
         [Fact]
         public void SkipWhileAllTrue()
         {
diff --git a/src/libraries/System.Linq/tests/TakeLastTests.cs b/src/libraries/System.Linq/tests/TakeLastTests.cs
index 31b58d5bf017ae..b39d59e94263a6 100644
--- a/src/libraries/System.Linq/tests/TakeLastTests.cs
+++ b/src/libraries/System.Linq/tests/TakeLastTests.cs
@@ -9,6 +9,12 @@ namespace System.Linq.Tests
 {
     public class TakeLastTests : EnumerableTests
     {
+        [Fact]
+        public void SkipLastThrowsOnNull()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).TakeLast(10));
+        }
+
         [Theory]
         [MemberData(nameof(EnumerableData), MemberType = typeof(SkipTakeData))]
         public void TakeLast(IEnumerable<int> source, int count)
diff --git a/src/libraries/System.Linq/tests/TakeTests.cs b/src/libraries/System.Linq/tests/TakeTests.cs
index 93a0405bfaf312..9dfd829e5d9efa 100644
--- a/src/libraries/System.Linq/tests/TakeTests.cs
+++ b/src/libraries/System.Linq/tests/TakeTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -2031,5 +2032,37 @@ public void EmptySource_DoNotThrowException_EnumerablePartition()
             Assert.Empty(EnumerablePartitionOrEmpty(source).Take(3..^8));
             Assert.Empty(EnumerablePartitionOrEmpty(source).Take(^6..^7));
         }
+
+        [Fact]
+        public void SkipTakeOnIListIsIList()
+        {
+            IList<int> list = new ReadOnlyCollection<int>(Enumerable.Range(0, 100).ToList());
+            IList<int> skipTake = Assert.IsAssignableFrom<IList<int>>(list.Skip(10).Take(20));
+
+            Assert.True(skipTake.IsReadOnly);
+            Assert.Equal(20, skipTake.Count);
+            int[] results = new int[20];
+            skipTake.CopyTo(results, 0);
+            for (int i = 0; i < 20; i++)
+            {
+                Assert.Equal(i + 10, skipTake[i]);
+                Assert.Equal(i + 10, results[i]);
+                Assert.True(skipTake.Contains(i + 10));
+                Assert.True(skipTake.IndexOf(i + 10) == i);
+            }
+
+            Assert.False(skipTake.Contains(9));
+            Assert.False(skipTake.Contains(30));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => skipTake[-1]);
+            Assert.Throws<ArgumentOutOfRangeException>(() => skipTake[20]);
+
+            Assert.Throws<NotSupportedException>(() => skipTake.Add(42));
+            Assert.Throws<NotSupportedException>(() => skipTake.Clear());
+            Assert.Throws<NotSupportedException>(() => skipTake.Insert(0, 42));
+            Assert.Throws<NotSupportedException>(() => skipTake.Remove(42));
+            Assert.Throws<NotSupportedException>(() => skipTake.RemoveAt(0));
+            Assert.Throws<NotSupportedException>(() => skipTake[0] = 42);
+        }
     }
 }
diff --git a/src/libraries/System.Linq/tests/TakeWhileTests.cs b/src/libraries/System.Linq/tests/TakeWhileTests.cs
index 55f02459978a00..18589d97192b0f 100644
--- a/src/libraries/System.Linq/tests/TakeWhileTests.cs
+++ b/src/libraries/System.Linq/tests/TakeWhileTests.cs
@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections;
 using System.Collections.Generic;
 using Xunit;
 
@@ -9,6 +8,13 @@ namespace System.Linq.Tests
 {
     public class TakeWhileTests : EnumerableTests
     {
+        [Fact]
+        public void Empty()
+        {
+            Assert.Equal(Enumerable.Empty<int>(), Enumerable.Empty<int>().TakeWhile(i => i < 40));
+            Assert.Equal(Enumerable.Empty<int>(), Enumerable.Empty<int>().TakeWhile((i, index) => i < 40));
+        }
+
         [Fact]
         public void SameResultsRepeatCallsIntQuery()
         {
diff --git a/src/libraries/System.Linq/tests/ToLookupTests.cs b/src/libraries/System.Linq/tests/ToLookupTests.cs
index 8d1f1f5fd00822..d2f81e9a662d5c 100644
--- a/src/libraries/System.Linq/tests/ToLookupTests.cs
+++ b/src/libraries/System.Linq/tests/ToLookupTests.cs
@@ -1,10 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Reflection;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -53,6 +51,14 @@ from x4 in q2
             Assert.Equal(q.ToLookup(e => e.a1), q.ToLookup(e => e.a1));
         }
 
+        [Fact]
+        public void Empty()
+        {
+            AssertMatches(Enumerable.Empty<int>(), Enumerable.Empty<int>(), Enumerable.Empty<int>().ToLookup(i => i));
+            Assert.False(Enumerable.Empty<int>().ToLookup(i => i).Contains(0));
+            Assert.Empty(Enumerable.Empty<int>().ToLookup(i => i)[0]);
+        }
+
         [Fact]
         public void NullKeyIncluded()
         {
@@ -289,6 +295,18 @@ public void ApplyResultSelectorForGroup(int enumType)
             Assert.Equal(expected, result);
         }
 
+        [Fact]
+        public void ApplyResultSelector()
+        {
+            Lookup<int, int> lookup = (Lookup<int, int>)new int[] { 1, 2, 2, 3, 3, 3 }.ToLookup(i => i);
+            IEnumerable<int> sums = lookup.ApplyResultSelector((key, elements) =>
+            {
+                Assert.Equal(key, elements.Count());
+                return elements.Sum();
+            });
+            Assert.Equal([1, 4, 9], sums);
+        }
+
         [Theory]
         [InlineData(0)]
         [InlineData(1)]
@@ -302,6 +320,7 @@ public void LookupImplementsICollection(int count)
 
             var collection = (ICollection<IGrouping<string, int>>)Enumerable.Range(0, count).ToLookup(i => i.ToString());
             Assert.Equal(count, collection.Count);
+            Assert.True(collection.IsReadOnly);
             Assert.Throws<NotSupportedException>(() => collection.Add(null));
             Assert.Throws<NotSupportedException>(() => collection.Remove(null));
             Assert.Throws<NotSupportedException>(() => collection.Clear());
@@ -313,6 +332,7 @@ public void LookupImplementsICollection(int count)
                 Assert.True(collection.Contains(first));
                 Assert.True(collection.Contains(last));
             }
+            Assert.False(collection.Contains(new NopGrouping()));
 
             IGrouping<string, int>[] items = new IGrouping<string, int>[count];
             collection.CopyTo(items, 0);
@@ -321,6 +341,13 @@ public void LookupImplementsICollection(int count)
             Assert.Equal(items, Enumerable.Range(0, count).ToLookup(i => i.ToString()).ToList());
         }
 
+        private sealed class NopGrouping : IGrouping<string, int>
+        {
+            public string Key => "";
+            public IEnumerator<int> GetEnumerator() => ((IList<int>)Array.Empty<int>()).GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
         public class Membership
         {
             public int Id { get; set; }
diff --git a/src/libraries/System.Linq/tests/WhereTests.cs b/src/libraries/System.Linq/tests/WhereTests.cs
index a6bc625e9e4936..a25b3f1abf9c31 100644
--- a/src/libraries/System.Linq/tests/WhereTests.cs
+++ b/src/libraries/System.Linq/tests/WhereTests.cs
@@ -1094,6 +1094,50 @@ public void ToCollection(IEnumerable<int> source)
             }
         }
 
+        [Fact]
+        public void WhereFirstLast()
+        {
+            Assert.All(IdentityTransforms<int>(), transform =>
+            {
+                IEnumerable<int> data = transform(Enumerable.Range(0, 10));
+
+                Assert.Equal(3, data.Where(i => i == 3).First());
+                Assert.Equal(0, data.Where(i => i % 2 == 0).First());
+
+                Assert.Equal(3, data.Where(i => i == 3).Last());
+                Assert.Equal(8, data.Where(i => i % 2 == 0).Last());
+
+                Assert.Equal(3, data.Where(i => i == 3).ElementAt(0));
+                Assert.Equal(8, data.Where(i => i % 2 == 0).ElementAt(4));
+
+                Assert.Throws<InvalidOperationException>(() => data.Where(i => i == 10).First());
+                Assert.Throws<InvalidOperationException>(() => data.Where(i => i == 10).Last());
+                Assert.Throws<ArgumentOutOfRangeException>(() => data.Where(i => i == 10).ElementAt(0));
+            });
+        }
+
+        [Fact]
+        public void WhereSelectFirstLast()
+        {
+            Assert.All(IdentityTransforms<int>(), transform =>
+            {
+                IEnumerable<int> data = transform(Enumerable.Range(0, 10));
+
+                Assert.Equal(6, data.Where(i => i == 3).Select(i => i * 2).First());
+                Assert.Equal(0, data.Where(i => i % 2 == 0).Select(i => i * 2).First());
+
+                Assert.Equal(6, data.Where(i => i == 3).Select(i => i * 2).Last());
+                Assert.Equal(16, data.Where(i => i % 2 == 0).Select(i => i * 2).Last());
+
+                Assert.Equal(6, data.Where(i => i == 3).Select(i => i * 2).ElementAt(0));
+                Assert.Equal(16, data.Where(i => i % 2 == 0).Select(i => i * 2).ElementAt(4));
+
+                Assert.Throws<InvalidOperationException>(() => data.Where(i => i == 10).Select(i => i * 2).First());
+                Assert.Throws<InvalidOperationException>(() => data.Where(i => i == 10).Select(i => i * 2).Last());
+                Assert.Throws<ArgumentOutOfRangeException>(() => data.Where(i => i == 10).Select(i => i * 2).ElementAt(0));
+            });
+        }
+
         public static IEnumerable<object[]> ToCollectionData()
         {
             IEnumerable<int> seq = GenerateRandomSequnce(seed: 0xdeadbeef, count: 10);

From 8a09e9f1532a208788a3aea3e0d8346482ef7ae8 Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 27 Feb 2024 21:21:06 -0500
Subject: [PATCH 7/7] Disable speed-optimized test on wasm

---
 src/libraries/System.Linq/tests/TakeTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libraries/System.Linq/tests/TakeTests.cs b/src/libraries/System.Linq/tests/TakeTests.cs
index 9dfd829e5d9efa..b19c69ab0fd9af 100644
--- a/src/libraries/System.Linq/tests/TakeTests.cs
+++ b/src/libraries/System.Linq/tests/TakeTests.cs
@@ -2033,7 +2033,7 @@ public void EmptySource_DoNotThrowException_EnumerablePartition()
             Assert.Empty(EnumerablePartitionOrEmpty(source).Take(^6..^7));
         }
 
-        [Fact]
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsSpeedOptimized))]
         public void SkipTakeOnIListIsIList()
         {
             IList<int> list = new ReadOnlyCollection<int>(Enumerable.Range(0, 100).ToList());