diff --git a/src/System.Linq/src/System/Linq/Enumerable.cs b/src/System.Linq/src/System/Linq/Enumerable.cs
index 8da90277886f..be10b6c4ed8a 100644
--- a/src/System.Linq/src/System/Linq/Enumerable.cs
+++ b/src/System.Linq/src/System/Linq/Enumerable.cs
@@ -6,7 +6,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Threading;
 
 namespace System.Linq
 {
@@ -48,6 +47,8 @@ public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSo
             if (selector == null) throw Error.ArgumentNull("selector");
             Iterator<TSource> iterator = source as Iterator<TSource>;
             if (iterator != null) return iterator.Select(selector);
+            IPartition<TSource> partition = source as IPartition<TSource>;
+            if (partition != null) return new SelectIPartitionIterator<TSource, TResult>(partition, selector);
             IList<TSource> ilist = source as IList<TSource>;
             if (ilist != null)
             {
@@ -530,7 +531,7 @@ public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> s
         }
 
 
-        internal sealed class SelectArrayIterator<TSource, TResult> : Iterator<TResult>, IArrayProvider<TResult>, IListProvider<TResult>
+        internal sealed class SelectArrayIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>, IIListProvider<TResult>
         {
             private readonly TSource[] _source;
             private readonly Func<TSource, TResult> _selector;
@@ -585,9 +586,59 @@ public List<TResult> ToList()
                 }
                 return results;
             }
+
+            public IPartition<TResult> Skip(int count)
+            {
+                return count == 0
+                    ? (IPartition<TResult>)new SelectArrayIterator<TSource, TResult>(_source, _selector)
+                    : new SelectIPartitionIterator<TSource, TResult>(new SkipListIterator<TSource>(_source, count, int.MaxValue), _selector);
+            }
+
+            public IPartition<TResult> Take(int count)
+            {
+                return count >= _source.Length
+                    ? (IPartition<TResult>)new SelectArrayIterator<TSource, TResult>(_source, _selector)
+                    : new SelectIPartitionIterator<TSource, TResult>(new SkipListIterator<TSource>(_source, 0, count - 1), _selector);
+            }
+
+            public bool TryGetElementAt(int index, out TResult element)
+            {
+                if ((uint)index >= (uint)_source.Length)
+                {
+                    element = default(TResult);
+                    return false;
+                }
+
+                element = _selector(_source[index]);
+                return true;
+            }
+
+            public bool TryGetFirst(out TResult first)
+            {
+                if (_source.Length == 0)
+                {
+                    first = default(TResult);
+                    return false;
+                }
+
+                first = _selector(_source[0]);
+                return true;
+            }
+
+            public bool TryGetLast(out TResult last)
+            {
+                if (_source.Length == 0)
+                {
+                    last = default(TResult);
+                    return false;
+                }
+
+                last = _selector(_source[_source.Length - 1]);
+                return true;
+            }
         }
 
-        internal sealed class SelectListIterator<TSource, TResult> : Iterator<TResult>, IArrayProvider<TResult>, IListProvider<TResult>
+        internal sealed class SelectListIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>, IIListProvider<TResult>
         {
             private readonly List<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
@@ -651,9 +702,57 @@ public List<TResult> ToList()
                 }
                 return results;
             }
+
+            public IPartition<TResult> Skip(int count)
+            {
+                return count == 0
+                    ? (IPartition<TResult>)new SelectListIterator<TSource, TResult>(_source, _selector)
+                    : new SelectIPartitionIterator<TSource, TResult>(new SkipListIterator<TSource>(_source, count, int.MaxValue), _selector);
+            }
+
+            public IPartition<TResult> Take(int count)
+            {
+                return new SelectIPartitionIterator<TSource, TResult>(new SkipListIterator<TSource>(_source, 0, count - 1), _selector);
+            }
+
+            public bool TryGetElementAt(int index, out TResult element)
+            {
+                if ((uint)index >= (uint)_source.Count)
+                {
+                    element = default(TResult);
+                    return false;
+                }
+
+                element = _selector(_source[index]);
+                return true;
+            }
+
+            public bool TryGetFirst(out TResult first)
+            {
+                if (_source.Count == 0)
+                {
+                    first = default(TResult);
+                    return false;
+                }
+
+                first = _selector(_source[0]);
+                return true;
+            }
+
+            public bool TryGetLast(out TResult result)
+            {
+                if (_source.Count == 0)
+                {
+                    result = default(TResult);
+                    return false;
+                }
+
+                result = _selector(_source[_source.Count - 1]);
+                return true;
+            }
         }
 
-        internal sealed class SelectIListIterator<TSource, TResult> : Iterator<TResult>, IArrayProvider<TResult>, IListProvider<TResult>
+        internal sealed class SelectIListIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>, IIListProvider<TResult>
         {
             private readonly IList<TSource> _source;
             private readonly Func<TSource, TResult> _selector;
@@ -727,31 +826,159 @@ public List<TResult> ToList()
                 }
                 return results;
             }
+
+            public IPartition<TResult> Skip(int count)
+            {
+                return count == 0
+                    ? (IPartition<TResult>)new SelectIListIterator<TSource, TResult>(_source, _selector)
+                    : new SelectIPartitionIterator<TSource, TResult>(new SkipListIterator<TSource>(_source, count, int.MaxValue), _selector);
+            }
+
+            public IPartition<TResult> Take(int count)
+            {
+                return new SelectIPartitionIterator<TSource, TResult>(new SkipListIterator<TSource>(_source, 0, count - 1), _selector);
+            }
+
+            public bool TryGetElementAt(int index, out TResult element)
+            {
+                if ((uint)index >= (uint)_source.Count)
+                {
+                    element = default(TResult);
+                    return false;
+                }
+
+                element = _selector(_source[index]);
+                return true;
+            }
+
+            public bool TryGetFirst(out TResult first)
+            {
+                if (_source.Count == 0)
+                {
+                    first = default(TResult);
+                    return false;
+                }
+
+                first = _selector(_source[0]);
+                return true;
+            }
+
+            public bool TryGetLast(out TResult last)
+            {
+                if (_source.Count == 0)
+                {
+                    last = default(TResult);
+                    return false;
+                }
+
+                last = _selector(_source[_source.Count - 1]);
+                return true;
+            }
         }
 
-        //public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
-        //    if (source == null) throw Error.ArgumentNull("source");
-        //    if (predicate == null) throw Error.ArgumentNull("predicate");
-        //    return WhereIterator<TSource>(source, predicate);
-        //}
+        internal sealed class SelectIPartitionIterator<TSource, TResult> : Iterator<TResult>, IPartition<TResult>
+        {
+            private readonly IPartition<TSource> _source;
+            private readonly Func<TSource, TResult> _selector;
+            private IEnumerator<TSource> _enumerator;
 
-        //static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate) {
-        //    foreach (TSource element in source) {
-        //        if (predicate(element)) yield return element;
-        //    }
-        //}
+            public SelectIPartitionIterator(IPartition<TSource> source, Func<TSource, TResult> selector)
+            {
+                Debug.Assert(source != null);
+                Debug.Assert(selector != null);
+                _source = source;
+                _selector = selector;
+            }
 
-        //public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector) {
-        //    if (source == null) throw Error.ArgumentNull("source");
-        //    if (selector == null) throw Error.ArgumentNull("selector");
-        //    return SelectIterator<TSource, TResult>(source, selector);
-        //}
+            public override Iterator<TResult> Clone()
+            {
+                return new SelectIPartitionIterator<TSource, TResult>(_source, _selector);
+            }
+
+            public override bool MoveNext()
+            {
+                switch (state)
+                {
+                    case 1:
+                        _enumerator = _source.GetEnumerator();
+                        state = 2;
+                        goto case 2;
+                    case 2:
+                        if (_enumerator.MoveNext())
+                        {
+                            current = _selector(_enumerator.Current);
+                            return true;
+                        }
+                        Dispose();
+                        break;
+                }
+                return false;
+            }
+
+            public override void Dispose()
+            {
+                if (_enumerator != null)
+                {
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                }
+                base.Dispose();
+            }
+
+            public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
+            {
+                return new SelectIPartitionIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector));
+            }
+
+            public IPartition<TResult> Skip(int count)
+            {
+                return new SelectIPartitionIterator<TSource, TResult>(_source.Skip(count), _selector);
+            }
+
+            public IPartition<TResult> Take(int count)
+            {
+                return new SelectIPartitionIterator<TSource, TResult>(_source.Take(count), _selector);
+            }
+
+            public bool TryGetElementAt(int index, out TResult element)
+            {
+                TSource input;
+                if (_source.TryGetElementAt(index, out input))
+                {
+                    element = _selector(input);
+                    return true;
+                }
+
+                element = default(TResult);
+                return false;
+            }
+
+            public bool TryGetFirst(out TResult first)
+            {
+                TSource input;
+                if (_source.TryGetFirst(out input))
+                {
+                    first = _selector(input);
+                    return true;
+                }
+
+                first = default(TResult);
+                return false;
+            }
+
+            public bool TryGetLast(out TResult last)
+            {
+                TSource input;
+                if (_source.TryGetLast(out input))
+                {
+                    last = _selector(input);
+                    return true;
+                }
 
-        //static IEnumerable<TResult> SelectIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult> selector) {
-        //    foreach (TSource element in source) {
-        //        yield return selector(element);
-        //    }
-        //}
+                last = default(TResult);
+                return false;
+            }
+        }
 
         public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
         {
@@ -836,6 +1063,8 @@ public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> sourc
             if (count <= 0) return new EmptyPartition<TSource>();
             IPartition<TSource> partition = source as IPartition<TSource>;
             if (partition != null) return partition.Take(count);
+            IList<TSource> sourceList = source as IList<TSource>;
+            if (sourceList != null) return new SkipListIterator<TSource>(sourceList, 0, count - 1);
             return TakeIterator<TSource>(source, count);
         }
 
@@ -889,14 +1118,128 @@ public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> sourc
             IPartition<TSource> partition = source as IPartition<TSource>;
             if (partition != null) return partition.Skip(count);
             IList<TSource> sourceList = source as IList<TSource>;
-            return sourceList != null ? SkipList(sourceList, count) : SkipIterator<TSource>(source, count);
+            return sourceList != null ? new SkipListIterator<TSource>(sourceList, count, int.MaxValue) : SkipIterator<TSource>(source, count);
         }
 
-        private static IEnumerable<TSource> SkipList<TSource>(IList<TSource> source, int count)
+        private sealed class SkipListIterator<TSource> : Iterator<TSource>, IPartition<TSource>, IIListProvider<TSource>
         {
-            while (count < source.Count)
+            private readonly IList<TSource> _source;
+            private readonly int _minIndex;
+            private readonly int _maxIndex;
+            private int _index;
+
+            public SkipListIterator(IList<TSource> source, int minIndex, int maxIndex)
+            {
+                Debug.Assert(source != null);
+                Debug.Assert(minIndex >= 0);
+                Debug.Assert(minIndex <= maxIndex);
+                _source = source;
+                _minIndex = minIndex;
+                _maxIndex = maxIndex;
+            }
+
+            public override Iterator<TSource> Clone()
+            {
+                return new SkipListIterator<TSource>(_source, _minIndex, _maxIndex);
+            }
+
+            public override bool MoveNext()
+            {
+                switch(state)
+                {
+                    case 1:
+                        _index = _minIndex;
+                        state = 2;
+                        goto case 2;
+                    case 2:
+                        if (_index <= _maxIndex && _index < _source.Count)
+                        {
+                            current = _source[_index];
+                            ++_index;
+                            return true;
+                        }
+                        break;
+                }
+                Dispose();
+                return false;
+            }
+
+            public IPartition<TSource> Skip(int count)
+            {
+                int minIndex = _minIndex + count;
+                return minIndex >= _maxIndex
+                    ? (IPartition<TSource>)new EmptyPartition<TSource>()
+                    : new SkipListIterator<TSource>(_source, minIndex, _maxIndex);
+            }
+
+            public IPartition<TSource> Take(int count)
+            {
+                int maxIndex = _minIndex + count - 1;
+                if (maxIndex >= _maxIndex) maxIndex = _maxIndex;
+                return new SkipListIterator<TSource>(_source, _minIndex, maxIndex);
+            }
+
+            public bool TryGetElementAt(int index, out TSource element)
+            {
+                if ((uint)index > (uint)_maxIndex - _minIndex || index >= _source.Count - _minIndex)
+                {
+                    element = default(TSource);
+                    return false;
+                }
+
+                element = _source[_minIndex + index];
+                return true;
+            }
+
+            public bool TryGetFirst(out TSource first)
+            {
+                if (_source.Count <= _minIndex)
+                {
+                    first = default(TSource);
+                    return false;
+                }
+
+                first = _source[_minIndex];
+                return true;
+            }
+
+            public bool TryGetLast(out TSource last)
             {
-                yield return source[count++];
+                int lastIndex = _source.Count - 1;
+                if (lastIndex < _minIndex)
+                {
+                    last = default(TSource);
+                    return false;
+                }
+
+                last = _source[lastIndex > _maxIndex ? _maxIndex : lastIndex];
+                return true;
+            }
+
+            public TSource[] ToArray()
+            {
+                int lastIndex = _source.Count - 1;
+                if (lastIndex < _minIndex) return new TSource[0];
+                if (lastIndex > _maxIndex) lastIndex = _maxIndex;
+                TSource[] array = new TSource[lastIndex - _minIndex + 1];
+                int curIdx = _minIndex;
+                for (int i = 0; i != array.Length; ++i)
+                {
+                    array[i] = _source[curIdx];
+                    ++curIdx;
+                }
+                return array;
+            }
+
+            public List<TSource> ToList()
+            {
+                int lastIndex = _source.Count - 1;
+                if (lastIndex < _minIndex) return new List<TSource>();
+                if (lastIndex > _maxIndex) lastIndex = _maxIndex;
+                List<TSource> list = new List<TSource>(lastIndex - _minIndex + 1);
+                for (int i = _minIndex; i <= lastIndex; ++i)
+                    list.Add(_source[i]);
+                return list;
             }
         }
 
@@ -1138,43 +1481,189 @@ private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(IEnume
         public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
-            return DistinctIterator<TSource>(source, null);
+            return new DistinctIterator<TSource>(source, null);
         }
 
         public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
         {
             if (source == null) throw Error.ArgumentNull("source");
-            return DistinctIterator<TSource>(source, comparer);
+            return new DistinctIterator<TSource>(source, comparer);
         }
 
-        private static IEnumerable<TSource> DistinctIterator<TSource>(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
+        private sealed class DistinctIterator<TSource> : Iterator<TSource>, IIListProvider<TSource>
         {
-            Set<TSource> set = new Set<TSource>(comparer);
-            foreach (TSource element in source)
-                if (set.Add(element)) yield return element;
+            private readonly IEnumerable<TSource> _source;
+            private readonly IEqualityComparer<TSource> _comparer;
+            private Set<TSource> _set;
+            private IEnumerator<TSource> _enumerator;
+
+            public DistinctIterator(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
+            {
+                _source = source;
+                _comparer = comparer;
+            }
+
+            public override Iterator<TSource> Clone()
+            {
+                return new DistinctIterator<TSource>(_source, _comparer);
+            }
+
+            public override bool MoveNext()
+            {
+                switch (state)
+                {
+                    case 1:
+                        _set = new Set<TSource>(_comparer);
+                        _enumerator = _source.GetEnumerator();
+                        state = 2;
+                        goto case 2;
+                    case 2:
+                        while (_enumerator.MoveNext())
+                        {
+                            TSource element = _enumerator.Current;
+                            if (_set.Add(element))
+                            {
+                                current = element;
+                                return true;
+                            }
+                        }
+                        Dispose();
+                        break;
+                }
+                return false;
+            }
+
+            public override void Dispose()
+            {
+                if (_enumerator != null)
+                {
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                }
+                base.Dispose();
+            }
+
+            private Set<TSource> FillList()
+            {
+                Set<TSource> set = new Set<TSource>(_comparer);
+                foreach (TSource element in _source)
+                    set.Add(element);
+                return set;
+            }
+
+            public TSource[] ToArray()
+            {
+                return FillList().ToArray();
+            }
+
+            public List<TSource> ToList()
+            {
+                return FillList().ToList();
+            }
         }
 
         public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
         {
             if (first == null) throw Error.ArgumentNull("first");
             if (second == null) throw Error.ArgumentNull("second");
-            return UnionIterator<TSource>(first, second, null);
+            return new UnionIterator<TSource>(first, second, null);
         }
 
         public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
         {
             if (first == null) throw Error.ArgumentNull("first");
             if (second == null) throw Error.ArgumentNull("second");
-            return UnionIterator<TSource>(first, second, comparer);
+            return new UnionIterator<TSource>(first, second, comparer);
         }
 
-        private static IEnumerable<TSource> UnionIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
-        {
-            Set<TSource> set = new Set<TSource>(comparer);
-            foreach (TSource element in first)
-                if (set.Add(element)) yield return element;
-            foreach (TSource element in second)
-                if (set.Add(element)) yield return element;
+        private sealed class UnionIterator<TSource> : Iterator<TSource>, IIListProvider<TSource>
+        {
+            private readonly IEnumerable<TSource> _first;
+            private readonly IEnumerable<TSource> _second;
+            private readonly IEqualityComparer<TSource> _comparer;
+            private Set<TSource> _set;
+            private IEnumerator<TSource> _enumerator;
+
+            public UnionIterator(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
+            {
+                _first = first;
+                _second = second;
+                _comparer = comparer;
+            }
+
+            public override Iterator<TSource> Clone()
+            {
+                return new UnionIterator<TSource>(_first, _second, _comparer);
+            }
+
+            private bool GetNext()
+            {
+                while (_enumerator.MoveNext())
+                {
+                    TSource element = _enumerator.Current;
+                    if (_set.Add(element))
+                    {
+                        current = element;
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            public override bool MoveNext()
+            {
+                switch (state)
+                {
+                    case 1:
+                        _set = new Set<TSource>(_comparer);
+                        _enumerator = _first.GetEnumerator();
+                        state = 2;
+                        goto case 2;
+                    case 2:
+                        if (GetNext())
+                            return true;
+                        _enumerator.Dispose();
+                        _enumerator = _second.GetEnumerator();
+                        state = 3;
+                        goto case 3;
+                    case 3:
+                        if (GetNext())
+                            return true;
+                        Dispose();
+                        break;
+                }
+                return false;
+            }
+
+            public override void Dispose()
+            {
+                if (_enumerator != null)
+                {
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                }
+                base.Dispose();
+            }
+
+            private Set<TSource> FillList()
+            {
+                Set<TSource> set = new Set<TSource>(_comparer);
+                foreach (TSource element in _first)
+                    set.Add(element);
+                foreach (TSource element in _second)
+                    set.Add(element);
+                return set;
+            }
+
+            public TSource[] ToArray()
+            {
+                return FillList().ToArray();
+            }
+
+            public List<TSource> ToList()
+            {
+                return FillList().ToList();
+            }
         }
 
         public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
@@ -1224,13 +1713,69 @@ private static IEnumerable<TSource> ExceptIterator<TSource>(IEnumerable<TSource>
         public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
-            return ReverseIterator<TSource>(source);
+            return new ReverseIterator<TSource>(source);
         }
 
-        private static IEnumerable<TSource> ReverseIterator<TSource>(IEnumerable<TSource> source)
+        private sealed class ReverseIterator<TSource> : Iterator<TSource>, IIListProvider<TSource>
         {
-            Buffer<TSource> buffer = new Buffer<TSource>(source);
-            for (int i = buffer.count - 1; i >= 0; i--) yield return buffer.items[i];
+            private readonly IEnumerable<TSource> _source;
+            private Buffer<TSource> _buffer;
+            private int _index;
+
+            public ReverseIterator(IEnumerable<TSource> source)
+            {
+                Debug.Assert(source != null);
+                _source = source;
+            }
+
+            public override Iterator<TSource> Clone()
+            {
+                return new ReverseIterator<TSource>(_source);
+            }
+
+            public override bool MoveNext()
+            {
+                switch(state)
+                {
+                    case 1:
+                        _buffer = new Buffer<TSource>(_source);
+                        _index = _buffer.count - 1;
+                        state = 2;
+                        goto case 2;
+                    case 2:
+                        if (_index >= 0)
+                        {
+                            current = _buffer.items[_index];
+                            --_index;
+                            return true;
+                        }
+                        break;
+                }
+                Dispose();
+                return false;
+            }
+
+            public TSource[] ToArray()
+            {
+                Buffer<TSource> buffer = new Buffer<TSource>(_source);
+                int count = buffer.count;
+                TSource[] sourceArray = buffer.items;
+                TSource[] array = new TSource[count];
+                for (int i = 0, sourceIdx = count - 1; i != array.Length; ++i, --sourceIdx)
+                    array[i] = sourceArray[sourceIdx];
+                return array;
+            }
+
+            public List<TSource> ToList()
+            {
+                Buffer<TSource> buffer = new Buffer<TSource>(_source);
+                int count = buffer.count;
+                TSource[] sourceArray = buffer.items;
+                List<TSource> list = new List<TSource>(count);
+                for (int i = count - 1; i >= 0; --i)
+                    list.Add(sourceArray[i]);
+                return list;
+            }
         }
 
         public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
@@ -1270,14 +1815,14 @@ public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSourc
         public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
-            IArrayProvider<TSource> arrayProvider = source as IArrayProvider<TSource>;
+            IIListProvider<TSource> arrayProvider = source as IIListProvider<TSource>;
             return arrayProvider != null ? arrayProvider.ToArray() : new Buffer<TSource>(source).ToArray();
         }
 
         public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
-            IListProvider<TSource> listProvider = source as IListProvider<TSource>;
+            IIListProvider<TSource> listProvider = source as IIListProvider<TSource>;
             return listProvider != null ? listProvider.ToList() : new List<TSource>(source);
         }
 
@@ -1452,17 +1997,25 @@ public static TSource First<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
             IPartition<TSource> partition = source as IPartition<TSource>;
-            if (partition != null) return partition.First();
-            IList<TSource> list = source as IList<TSource>;
-            if (list != null)
+            if (partition != null)
             {
-                if (list.Count > 0) return list[0];
+                TSource result;
+                if (partition.TryGetFirst(out result))
+                    return result;
             }
             else
             {
-                using (IEnumerator<TSource> e = source.GetEnumerator())
+                IList<TSource> list = source as IList<TSource>;
+                if (list != null)
                 {
-                    if (e.MoveNext()) return e.Current;
+                    if (list.Count > 0) return list[0];
+                }
+                else
+                {
+                    using (IEnumerator<TSource> e = source.GetEnumerator())
+                    {
+                        if (e.MoveNext()) return e.Current;
+                    }
                 }
             }
             throw Error.NoElements();
@@ -1485,7 +2038,12 @@ public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
             IPartition<TSource> partition = source as IPartition<TSource>;
-            if (partition != null) return partition.FirstOrDefault();
+            if (partition != null)
+            {
+                TSource result;
+                partition.TryGetFirst(out result);
+                return result;
+            }
             IList<TSource> list = source as IList<TSource>;
             if (list != null)
             {
@@ -1518,25 +2076,33 @@ public static TSource Last<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
             IPartition<TSource> partition = source as IPartition<TSource>;
-            if (partition != null) return partition.Last();
-            IList<TSource> list = source as IList<TSource>;
-            if (list != null)
+            if (partition != null)
             {
-                int count = list.Count;
-                if (count > 0) return list[count - 1];
+                TSource result;
+                if (partition.TryGetLast(out result))
+                    return result;
             }
             else
             {
-                using (IEnumerator<TSource> e = source.GetEnumerator())
+                IList<TSource> list = source as IList<TSource>;
+                if (list != null)
                 {
-                    if (e.MoveNext())
+                    int count = list.Count;
+                    if (count > 0) return list[count - 1];
+                }
+                else
+                {
+                    using (IEnumerator<TSource> e = source.GetEnumerator())
                     {
-                        TSource result;
-                        do
+                        if (e.MoveNext())
                         {
-                            result = e.Current;
-                        } while (e.MoveNext());
-                        return result;
+                            TSource result;
+                            do
+                            {
+                                result = e.Current;
+                            } while (e.MoveNext());
+                            return result;
+                        }
                     }
                 }
             }
@@ -1584,7 +2150,12 @@ public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null) throw Error.ArgumentNull("source");
             IPartition<TSource> partition = source as IPartition<TSource>;
-            if (partition != null) return partition.LastOrDefault();
+            if (partition != null)
+            {
+                TSource result;
+                partition.TryGetLast(out result);
+                return result;
+            }
             IList<TSource> list = source as IList<TSource>;
             if (list != null)
             {
@@ -1735,17 +2306,25 @@ public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int i
         {
             if (source == null) throw Error.ArgumentNull("source");
             IPartition<TSource> partition = source as IPartition<TSource>;
-            if (partition != null) return partition.ElementAt(index);
-            IList<TSource> list = source as IList<TSource>;
-            if (list != null) return list[index];
-            if (index >= 0)
+            if (partition != null)
             {
-                using (IEnumerator<TSource> e = source.GetEnumerator())
+                TSource result;
+                if (partition.TryGetElementAt(index, out result))
+                    return result;
+            }
+            else
+            {
+                IList<TSource> list = source as IList<TSource>;
+                if (list != null) return list[index];
+                if (index >= 0)
                 {
-                    while (e.MoveNext())
+                    using (IEnumerator<TSource> e = source.GetEnumerator())
                     {
-                        if (index == 0) return e.Current;
-                        index--;
+                        while (e.MoveNext())
+                        {
+                            if (index == 0) return e.Current;
+                            index--;
+                        }
                     }
                 }
             }
@@ -1756,7 +2335,12 @@ public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> sour
         {
             if (source == null) throw Error.ArgumentNull("source");
             IPartition<TSource> partition = source as IPartition<TSource>;
-            if (partition != null) return partition.ElementAtOrDefault(index);
+            if (partition != null)
+            {
+                TSource result;
+                partition.TryGetElementAt(index, out result);
+                return result;
+            }
             if (index >= 0)
             {
                 IList<TSource> list = source as IList<TSource>;
@@ -1787,7 +2371,7 @@ public static IEnumerable<int> Range(int start, int count)
             return new RangeIterator(start, count);
         }
 
-        private sealed class RangeIterator : Iterator<int>, IArrayProvider<int>, IListProvider<int>, IPartition<int>
+        private sealed class RangeIterator : Iterator<int>, IPartition<int>, IIListProvider<int>
         {
             private readonly int _start;
             private readonly int _end;
@@ -1862,35 +2446,28 @@ public IPartition<int> Take(int count)
                 return new RangeIterator(_start, count);
             }
 
-            public int ElementAt(int index)
+            public bool TryGetElementAt(int index, out int element)
             {
-                if ((uint)index >= (uint)(_end - _start)) throw Error.ArgumentOutOfRange("index");
-                return _start + index;
-            }
-
-            public int ElementAtOrDefault(int index)
-            {
-                return (uint)index >= (uint)(_end - _start) ? 0 : _start + index;
-            }
-
-            public int First()
-            {
-                return _start;
-            }
+                if ((uint)index >= (uint)(_end - _start))
+                {
+                    element = 0;
+                    return false;
+                }
 
-            public int FirstOrDefault()
-            {
-                return _start;
+                element = _start + index;
+                return true;
             }
 
-            public int Last()
+            public bool TryGetFirst(out int first)
             {
-                return _end - 1;
+                first = _start;
+                return true;
             }
 
-            public int LastOrDefault()
+            public bool TryGetLast(out int last)
             {
-                return _end - 1;
+                last = _end - 1;
+                return true;
             }
         }
 
@@ -1901,7 +2478,7 @@ public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
             return new RepeatIterator<TResult>(element, count);
         }
 
-        private sealed class RepeatIterator<TResult> : Iterator<TResult>, IArrayProvider<TResult>, IListProvider<TResult>, IPartition<TResult>
+        private sealed class RepeatIterator<TResult> : Iterator<TResult>, IPartition<TResult>, IIListProvider<TResult>
         {
             private readonly int _count;
             private int _sent;
@@ -1965,35 +2542,28 @@ public IPartition<TResult> Take(int count)
                 return new RepeatIterator<TResult>(current, count);
             }
 
-            public TResult ElementAt(int index)
-            {
-                if ((uint)index >= (uint)_count) throw Error.ArgumentOutOfRange("index");
-                return current;
-            }
-
-            public TResult ElementAtOrDefault(int index)
-            {
-                return (uint)index >= (uint)_count ? default(TResult) : current;
-            }
-
-            public TResult First()
+            public bool TryGetElementAt(int index, out TResult element)
             {
-                return current;
-            }
+                if ((uint)index >= (uint)_count)
+                {
+                    element = default(TResult);
+                    return false;
+                }
 
-            public TResult FirstOrDefault()
-            {
-                return current;
+                element = current;
+                return true;
             }
 
-            public TResult Last()
+            public bool TryGetFirst(out TResult first)
             {
-                return current;
+                first = current;
+                return true;
             }
 
-            public TResult LastOrDefault()
+            public bool TryGetLast(out TResult last)
             {
-                return current;
+                last = current;
+                return true;
             }
         }
 
@@ -3310,22 +3880,16 @@ public static decimal Average<TSource>(this IEnumerable<TSource> source, Func<TS
     }
 
     /// <summary>
-    /// An iterator that can produce an array through an optimized path.
+    /// An iterator that can produce an array or an <see cref="List{TElement}"/> through an optimized path.
     /// </summary>
-    internal interface IArrayProvider<TElement>
+    internal interface IIListProvider<TElement>
     {
         /// <summary>
         /// Produce an array of the sequence through an optimized path.
         /// </summary>
         /// <returns>The array.</returns>
         TElement[] ToArray();
-    }
 
-    /// <summary>
-    /// An iterator that can produce a <see cref="List{TElement}"/> through an optimized path.
-    /// </summary>
-    internal interface IListProvider<TElement>
-    {
         /// <summary>
         /// Produce a <see cref="List{TElement}"/> of the sequence through an optimized path.
         /// </summary>
@@ -3358,7 +3922,7 @@ public interface ILookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>
         bool Contains(TKey key);
     }
 
-    public class Lookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>, ILookup<TKey, TElement>, IArrayProvider<IGrouping<TKey, TElement>>, IListProvider<IGrouping<TKey, TElement>>
+    public class Lookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>, ILookup<TKey, TElement>, IIListProvider<IGrouping<TKey, TElement>>
     {
         private IEqualityComparer<TKey> _comparer;
         private Grouping<TKey, TElement>[] _groupings;
@@ -3429,7 +3993,7 @@ public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
             }
         }
 
-        IGrouping<TKey, TElement>[] IArrayProvider<IGrouping<TKey, TElement>>.ToArray()
+        IGrouping<TKey, TElement>[] IIListProvider<IGrouping<TKey, TElement>>.ToArray()
         {
             IGrouping<TKey, TElement>[] array = new IGrouping<TKey, TElement>[_count];
             int index = 0;
@@ -3446,7 +4010,7 @@ IGrouping<TKey, TElement>[] IArrayProvider<IGrouping<TKey, TElement>>.ToArray()
             return array;
         }
 
-        List<IGrouping<TKey, TElement>> IListProvider<IGrouping<TKey, TElement>>.ToList()
+        List<IGrouping<TKey, TElement>> IIListProvider<IGrouping<TKey, TElement>>.ToList()
         {
             List<IGrouping<TKey, TElement>> list = new List<IGrouping<TKey, TElement>>(_count);
             Grouping<TKey, TElement> g = _lastGrouping;
@@ -3647,8 +4211,10 @@ internal class Set<TElement>
         private int[] _buckets;
         private Slot[] _slots;
         private int _count;
-        private int _freeList;
-        private IEqualityComparer<TElement> _comparer;
+        private readonly IEqualityComparer<TElement> _comparer;
+#if DEBUG
+        private bool _haveRemoved;
+#endif
 
         public Set(IEqualityComparer<TElement> comparer)
         {
@@ -3656,18 +4222,36 @@ public Set(IEqualityComparer<TElement> comparer)
             _comparer = comparer;
             _buckets = new int[7];
             _slots = new Slot[7];
-            _freeList = -1;
         }
 
         // If value is not in set, add it and return true; otherwise return false
         public bool Add(TElement value)
         {
-            return !Find(value, true);
+#if DEBUG
+            Debug.Assert(!_haveRemoved, "This set assumes no adds after a removal. If your use requires adds after removal undo that optimization.");
+#endif
+            int hashCode = InternalGetHashCode(value);
+            for (int i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].next)
+            {
+                if (_slots[i].hashCode == hashCode && _comparer.Equals(_slots[i].value, value)) return false;
+            }
+            if (_count == _slots.Length) Resize();
+            int index = _count;
+            _count++;
+            int bucket = hashCode % _buckets.Length;
+            _slots[index].hashCode = hashCode;
+            _slots[index].value = value;
+            _slots[index].next = _buckets[bucket] - 1;
+            _buckets[bucket] = index + 1;
+            return true;
         }
 
         // If value is in set, remove it and return true; otherwise return false
         public bool Remove(TElement value)
         {
+#if DEBUG
+            _haveRemoved = true;
+#endif
             int hashCode = InternalGetHashCode(value);
             int bucket = hashCode % _buckets.Length;
             int last = -1;
@@ -3685,44 +4269,12 @@ public bool Remove(TElement value)
                     }
                     _slots[i].hashCode = -1;
                     _slots[i].value = default(TElement);
-                    _slots[i].next = _freeList;
-                    _freeList = i;
                     return true;
                 }
             }
             return false;
         }
 
-        private bool Find(TElement value, bool add)
-        {
-            int hashCode = InternalGetHashCode(value);
-            for (int i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].next)
-            {
-                if (_slots[i].hashCode == hashCode && _comparer.Equals(_slots[i].value, value)) return true;
-            }
-            if (add)
-            {
-                int index;
-                if (_freeList >= 0)
-                {
-                    index = _freeList;
-                    _freeList = _slots[index].next;
-                }
-                else
-                {
-                    if (_count == _slots.Length) Resize();
-                    index = _count;
-                    _count++;
-                }
-                int bucket = hashCode % _buckets.Length;
-                _slots[index].hashCode = hashCode;
-                _slots[index].value = value;
-                _slots[index].next = _buckets[bucket] - 1;
-                _buckets[bucket] = index + 1;
-            }
-            return false;
-        }
-
         private void Resize()
         {
             int newSize = checked(_count * 2 + 1);
@@ -3739,6 +4291,29 @@ private void Resize()
             _slots = newSlots;
         }
 
+        internal TElement[] ToArray()
+        {
+#if DEBUG
+            Debug.Assert(!_haveRemoved, "Optimised ToArray cannot be called if Remove has been called.");
+#endif
+            TElement[] array = new TElement[_count];
+            for (int i = 0; i != array.Length; ++i)
+                array[i] = _slots[i].value;
+            return array;
+        }
+
+        internal List<TElement> ToList()
+        {
+#if DEBUG
+            Debug.Assert(!_haveRemoved, "Optimised ToList cannot be called if Remove has been called.");
+#endif
+            int count = _count;
+            List<TElement> list = new List<TElement>(count);
+            for (int i = 0; i != count; ++i)
+                list.Add(_slots[i].value);
+            return list;
+        }
+
         internal int InternalGetHashCode(TElement value)
         {
             // Handle comparer implementations that throw when passed null
@@ -3786,7 +4361,7 @@ IEnumerator IEnumerable.GetEnumerator()
         }
     }
 
-    internal class GroupedEnumerable<TSource, TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>, IArrayProvider<IGrouping<TKey, TElement>>, IListProvider<IGrouping<TKey, TElement>>
+    internal class GroupedEnumerable<TSource, TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>, IIListProvider<IGrouping<TKey, TElement>>
     {
         private IEnumerable<TSource> _source;
         private Func<TSource, TKey> _keySelector;
@@ -3816,37 +4391,31 @@ IEnumerator IEnumerable.GetEnumerator()
 
         public IGrouping<TKey, TElement>[] ToArray()
         {
-            IArrayProvider<IGrouping<TKey, TElement>> lookup = Lookup<TKey, TElement>.Create<TSource>(_source, _keySelector, _elementSelector, _comparer);
+            IIListProvider<IGrouping<TKey, TElement>> lookup = Lookup<TKey, TElement>.Create<TSource>(_source, _keySelector, _elementSelector, _comparer);
             return lookup.ToArray();
         }
 
         public List<IGrouping<TKey, TElement>> ToList()
         {
-            IListProvider<IGrouping<TKey, TElement>> lookup = Lookup<TKey, TElement>.Create<TSource>(_source, _keySelector, _elementSelector, _comparer);
+            IIListProvider<IGrouping<TKey, TElement>> lookup = Lookup<TKey, TElement>.Create<TSource>(_source, _keySelector, _elementSelector, _comparer);
             return lookup.ToList();
         }
     }
 
-    internal interface IPartition<TElement> : IEnumerable<TElement>, IArrayProvider<TElement>
+    internal interface IPartition<TElement> : IEnumerable<TElement>
     {
         IPartition<TElement> Skip(int count);
 
         IPartition<TElement> Take(int count);
 
-        TElement ElementAt(int index);
-
-        TElement ElementAtOrDefault(int index);
+        bool TryGetElementAt(int index, out TElement element);
 
-        TElement First();
+        bool TryGetFirst(out TElement first);
 
-        TElement FirstOrDefault();
-
-        TElement Last();
-
-        TElement LastOrDefault();
+        bool TryGetLast(out TElement last);
     }
 
-    internal sealed class EmptyPartition<TElement> : IPartition<TElement>, IListProvider<TElement>, IEnumerator<TElement>
+    internal sealed class EmptyPartition<TElement> : IPartition<TElement>, IEnumerator<TElement>, IIListProvider<TElement>
     {
         public EmptyPartition()
         {
@@ -3899,34 +4468,22 @@ public IPartition<TElement> Take(int count)
             return new EmptyPartition<TElement>();
         }
 
-        public TElement ElementAt(int index)
-        {
-            throw Error.ArgumentOutOfRange("index");
-        }
-
-        public TElement ElementAtOrDefault(int index)
-        {
-            return default(TElement);
-        }
-
-        public TElement First()
-        {
-            throw Error.NoElements();
-        }
-
-        public TElement FirstOrDefault()
+        public bool TryGetElementAt(int index, out TElement element)
         {
-            return default(TElement);
+            element = default(TElement);
+            return false;
         }
 
-        public TElement Last()
+        public bool TryGetFirst(out TElement first)
         {
-            throw Error.NoElements();
+            first = default(TElement);
+            return false;
         }
 
-        public TElement LastOrDefault()
+        public bool TryGetLast(out TElement last)
         {
-            return default(TElement);
+            last = default(TElement);
+            return false;
         }
 
         public TElement[] ToArray()
@@ -3936,11 +4493,11 @@ public TElement[] ToArray()
 
         public List<TElement> ToList()
         {
-            return new List<TElement>(0);
+            return new List<TElement>();
         }
     }
 
-    internal sealed class OrderedPartition<TElement> : IPartition<TElement>
+    internal sealed class OrderedPartition<TElement> : IPartition<TElement>, IIListProvider<TElement>
     {
         private readonly OrderedEnumerable<TElement> _source;
         private readonly int _minIndex;
@@ -3978,46 +4535,39 @@ public IPartition<TElement> Take(int count)
             return new OrderedPartition<TElement>(_source, _minIndex, maxIndex);
         }
 
-        public TElement ElementAt(int index)
-        {
-            if ((uint)index > (uint)_maxIndex - _minIndex) throw Error.ArgumentOutOfRange("index");
-            return _source.ElementAt(index + _minIndex);
-        }
-
-        public TElement ElementAtOrDefault(int index)
+        public bool TryGetElementAt(int index, out TElement element)
         {
-            return (uint)index <= (uint)_maxIndex - _minIndex ? _source.ElementAtOrDefault(index + _minIndex) : default(TElement);
-        }
+            if ((uint)index > (uint)_maxIndex - _minIndex)
+            {
+                element = default(TElement);
+                return false;
+            }
 
-        public TElement First()
-        {
-            TElement result;
-            if (!_source.TryGetElementAt(_minIndex, out result)) throw Error.NoElements();
-            return result;
+            return _source.TryGetElementAt(index + _minIndex, out element);
         }
 
-        public TElement FirstOrDefault()
+        public bool TryGetFirst(out TElement first)
         {
-            return _source.ElementAtOrDefault(_minIndex);
+            return _source.TryGetElementAt(_minIndex, out first);
         }
 
-        public TElement Last()
+        public bool TryGetLast(out TElement element)
         {
-            return _source.Last(_minIndex, _maxIndex);
+            return _source.TryGetLast(_minIndex, _maxIndex, out element);
         }
 
-        public TElement LastOrDefault()
+        public TElement[] ToArray()
         {
-            return _source.LastOrDefault(_minIndex, _maxIndex);
+            return _source.ToArray(_minIndex, _maxIndex);
         }
 
-        public TElement[] ToArray()
+        public List<TElement> ToList()
         {
-            return _source.ToArray(_minIndex, _maxIndex);
+            return _source.ToList(_minIndex, _maxIndex);
         }
     }
 
-    internal abstract class OrderedEnumerable<TElement> : IOrderedEnumerable<TElement>, IArrayProvider<TElement>, IListProvider<TElement>, IPartition<TElement>
+    internal abstract class OrderedEnumerable<TElement> : IOrderedEnumerable<TElement>, IPartition<TElement>, IIListProvider<TElement>
     {
         internal IEnumerable<TElement> source;
 
@@ -4108,6 +4658,23 @@ internal TElement[] ToArray(int minIdx, int maxIdx)
             return array;
         }
 
+        internal List<TElement> ToList(int minIdx, int maxIdx)
+        {
+            Buffer<TElement> buffer = new Buffer<TElement>(source);
+            int count = buffer.count;
+            if (count <= minIdx) return new List<TElement>();
+            if (count <= maxIdx) maxIdx = count - 1;
+            if (minIdx == maxIdx) return new List<TElement>(1) { GetEnumerableSorter().ElementAt(buffer.items, count, minIdx) };
+            int[] map = SortedMap(buffer, minIdx, maxIdx);
+            List<TElement> list = new List<TElement>(maxIdx - minIdx + 1);
+            while (minIdx <= maxIdx)
+            {
+                list.Add(buffer.items[map[minIdx]]);
+                ++minIdx;
+            }
+            return list;
+        }
+
         private EnumerableSorter<TElement> GetEnumerableSorter()
         {
             return GetEnumerableSorter(null);
@@ -4161,21 +4728,7 @@ public bool TryGetElementAt(int index, out TElement result)
             return false;
         }
 
-        public TElement ElementAt(int index)
-        {
-            TElement result;
-            if (!TryGetElementAt(index, out result)) throw Error.ArgumentOutOfRange("index");
-            return result;
-        }
-
-        public TElement ElementAtOrDefault(int index)
-        {
-            TElement result;
-            TryGetElementAt(index, out result);
-            return result;
-        }
-
-        private bool TryGetFirst(out TElement result)
+        public bool TryGetFirst(out TElement result)
         {
             CachingComparer<TElement> comparer = GetComparer();
             using (IEnumerator<TElement> e = source.GetEnumerator())
@@ -4197,20 +4750,6 @@ private bool TryGetFirst(out TElement result)
             }
         }
 
-        public TElement FirstOrDefault()
-        {
-            TElement result;
-            TryGetFirst(out result);
-            return result;
-        }
-
-        public TElement First()
-        {
-            TElement result;
-            if (!TryGetFirst(out result)) throw Error.NoElements();
-            return result;
-        }
-
         public TElement First(Func<TElement, bool> predicate)
         {
             CachingComparer<TElement> comparer = GetComparer();
@@ -4253,29 +4792,16 @@ public TElement FirstOrDefault(Func<TElement, bool> predicate)
             }
         }
 
-        public TElement Last()
+        public bool TryGetLast(out TElement element)
         {
             CachingComparer<TElement> comparer = GetComparer();
             using (IEnumerator<TElement> e = source.GetEnumerator())
             {
-                if (!e.MoveNext()) throw Error.NoElements();
-                TElement value = e.Current;
-                comparer.SetElement(value);
-                while (e.MoveNext())
+                if (!e.MoveNext())
                 {
-                    TElement x = e.Current;
-                    if (comparer.Compare(x, false) >= 0) value = x;
+                    element = default(TElement);
+                    return false;
                 }
-                return value;
-            }
-        }
-
-        public TElement LastOrDefault()
-        {
-            CachingComparer<TElement> comparer = GetComparer();
-            using (IEnumerator<TElement> e = source.GetEnumerator())
-            {
-                if (!e.MoveNext()) return default(TElement);
                 TElement value = e.Current;
                 comparer.SetElement(value);
                 while (e.MoveNext())
@@ -4283,28 +4809,28 @@ public TElement LastOrDefault()
                     TElement x = e.Current;
                     if (comparer.Compare(x, false) >= 0) value = x;
                 }
-                return value;
+                element = value;
+                return true;
             }
+
         }
 
-        public TElement Last(int minIdx, int maxIdx)
+        public bool TryGetLast(int minIdx, int maxIdx, out TElement last)
         {
             Buffer<TElement> buffer = new Buffer<TElement>(source);
             int count = buffer.count;
-            if (minIdx >= count) throw Error.NoElements();
-            if (maxIdx < count - 1) return GetEnumerableSorter().ElementAt(buffer.items, count, maxIdx);
+            if (minIdx >= count)
+            {
+                last = default(TElement);
+                return false;
+            }
+            if (maxIdx < count - 1)
+                last = GetEnumerableSorter().ElementAt(buffer.items, count, maxIdx);
             // If we're here, we want the same results we would have got from
             // Last(), but we've already buffered our source.
-            return Last(buffer);
-        }
-
-        public TElement LastOrDefault(int minIdx, int maxIdx)
-        {
-            Buffer<TElement> buffer = new Buffer<TElement>(source);
-            int count = buffer.count;
-            if (minIdx >= count) return default(TElement);
-            if (maxIdx < count - 1) return GetEnumerableSorter().ElementAt(buffer.items, count, maxIdx);
-            return Last(buffer);
+            else
+                last = Last(buffer);
+            return true;
         }
 
         private TElement Last(Buffer<TElement> buffer)
@@ -4656,7 +5182,7 @@ internal struct Buffer<TElement>
 
         internal Buffer(IEnumerable<TElement> source)
         {
-            IArrayProvider<TElement> iterator = source as IArrayProvider<TElement>;
+            IIListProvider<TElement> iterator = source as IIListProvider<TElement>;
             if (iterator != null)
             {
                 TElement[] array = iterator.ToArray();
diff --git a/src/System.Linq/tests/DistinctTests.cs b/src/System.Linq/tests/DistinctTests.cs
index 4f954a69b6ee..32bcf9e5928c 100644
--- a/src/System.Linq/tests/DistinctTests.cs
+++ b/src/System.Linq/tests/DistinctTests.cs
@@ -198,5 +198,33 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void ToArray()
+        {
+            int?[] source = { 1, 1, 1, 2, 2, 2, null, null };
+            int?[] expected = { 1, 2, null };
+
+            Assert.Equal(expected, source.Distinct().ToArray());
+        }
+
+        [Fact]
+        public void ToList()
+        {
+            int?[] source = { 1, 1, 1, 2, 2, 2, null, null };
+            int?[] expected = { 1, 2, null };
+
+            Assert.Equal(expected, source.Distinct().ToList());
+        }
+
+        [Fact]
+        public void RepeatEnumerating()
+        {
+            int?[] source = { 1, 1, 1, 2, 2, 2, null, null };
+
+            var result = source.Distinct();
+
+            Assert.Equal(result, result);
+        }
     }
 }
diff --git a/src/System.Linq/tests/ElementAtOrDefaultTests.cs b/src/System.Linq/tests/ElementAtOrDefaultTests.cs
index a0fc8902b362..52c14c6c3a4e 100644
--- a/src/System.Linq/tests/ElementAtOrDefaultTests.cs
+++ b/src/System.Linq/tests/ElementAtOrDefaultTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -131,5 +132,35 @@ public void NullSource()
         {
             Assert.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).ElementAtOrDefault(2));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAtOrDefault(i));
+            Assert.Equal(0, source.ElementAtOrDefault(-1));
+            Assert.Equal(0, source.ElementAtOrDefault(4));
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.ToList().Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Equal(0, source.ElementAtOrDefault(-1));
+            Assert.Equal(0, source.ElementAtOrDefault(4));
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            var source = new ReadOnlyCollection<int>(new[] { 1, 2, 3, 4 }).Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Equal(0, source.ElementAtOrDefault(-1));
+            Assert.Equal(0, source.ElementAtOrDefault(4));
+        }
     }
 }
diff --git a/src/System.Linq/tests/ElementAtTests.cs b/src/System.Linq/tests/ElementAtTests.cs
index b7c3ef9258f5..dc2a9212e884 100644
--- a/src/System.Linq/tests/ElementAtTests.cs
+++ b/src/System.Linq/tests/ElementAtTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -131,5 +132,35 @@ public void NullSource()
         {
             Assert.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).ElementAt(2));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(4));
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.ToList().Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(4));
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            var source = new ReadOnlyCollection<int>(new[] { 1, 2, 3, 4 }).Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(4));
+        }
     }
 }
diff --git a/src/System.Linq/tests/FirstOrDefaultTests.cs b/src/System.Linq/tests/FirstOrDefaultTests.cs
index 4a6d2369257d..748b9c41c988 100644
--- a/src/System.Linq/tests/FirstOrDefaultTests.cs
+++ b/src/System.Linq/tests/FirstOrDefaultTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -194,5 +195,26 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).FirstOrDefault(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).FirstOrDefault());
+            Assert.Equal(0, new int[0].Select(i => i * 2 + 1).FirstOrDefault());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).FirstOrDefault());
+            Assert.Equal(0, new List<int>(0).Select(i => i * 2 + 1).FirstOrDefault());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(11, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).FirstOrDefault());
+            Assert.Equal(0, new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1).FirstOrDefault());
+        }
     }
 }
diff --git a/src/System.Linq/tests/FirstTests.cs b/src/System.Linq/tests/FirstTests.cs
index abcda8b354a6..a8a9f5e7fb54 100644
--- a/src/System.Linq/tests/FirstTests.cs
+++ b/src/System.Linq/tests/FirstTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -191,5 +192,29 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).First(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).First());
+            var emptySource = new int[0].Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.First());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).First());
+            var emptySource = new List<int>(0).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.First());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(11, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).First());
+            var emptySource = new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.First());
+        }
     }
 }
diff --git a/src/System.Linq/tests/GroupByTests.cs b/src/System.Linq/tests/GroupByTests.cs
index 7c5b8f719d4c..791a1e6c0e6c 100644
--- a/src/System.Linq/tests/GroupByTests.cs
+++ b/src/System.Linq/tests/GroupByTests.cs
@@ -630,5 +630,17 @@ public void GroupingWithResultsToList()
             Assert.Equal(4, groupedList.Count);
             Assert.Equal(source.GroupBy(r => r.Name, (r, e) => e), groupedList);
         }
+
+        [Fact]
+        public void EmptyGroupingToArray()
+        {
+            Assert.Empty(Enumerable.Empty<int>().GroupBy(i => i).ToArray());
+        }
+
+        [Fact]
+        public void EmptyGroupingToList()
+        {
+            Assert.Empty(Enumerable.Empty<int>().GroupBy(i => i).ToList());
+        }
     }
 }
\ No newline at end of file
diff --git a/src/System.Linq/tests/LastOrDefaultTests.cs b/src/System.Linq/tests/LastOrDefaultTests.cs
index 1b2413b3266e..43f5fc67df85 100644
--- a/src/System.Linq/tests/LastOrDefaultTests.cs
+++ b/src/System.Linq/tests/LastOrDefaultTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests.LegacyTests
@@ -244,5 +245,26 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).LastOrDefault(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).LastOrDefault());
+            Assert.Equal(0, new int[0].Select(i => i * 2 + 1).LastOrDefault());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).LastOrDefault());
+            Assert.Equal(0, new List<int>(0).Select(i => i * 2 + 1).LastOrDefault());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(17, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).LastOrDefault());
+            Assert.Equal(0, new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1).LastOrDefault());
+        }
     }
 }
diff --git a/src/System.Linq/tests/LastTests.cs b/src/System.Linq/tests/LastTests.cs
index 7512bfbe60bb..9ed77153fc2d 100644
--- a/src/System.Linq/tests/LastTests.cs
+++ b/src/System.Linq/tests/LastTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -239,5 +240,29 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).Last(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).Last());
+            var emptySource = new int[0].Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.Last());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).Last());
+            var emptySource = new List<int>(0).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.Last());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(17, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).Last());
+            var emptySource = new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.Last());
+        }
     }
 }
diff --git a/src/System.Linq/tests/OrderedSubsetting.cs b/src/System.Linq/tests/OrderedSubsetting.cs
index cf25c4b6203e..75e4695d2afd 100644
--- a/src/System.Linq/tests/OrderedSubsetting.cs
+++ b/src/System.Linq/tests/OrderedSubsetting.cs
@@ -302,24 +302,48 @@ public void ToArray()
             Assert.Equal(Enumerable.Range(10, 20), Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(10).Take(20).ToArray());
         }
 
+        [Fact]
+        public void ToList()
+        {
+            Assert.Equal(Enumerable.Range(10, 20), Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(10).Take(20).ToList());
+        }
+
         [Fact]
         public void EmptyToArray()
         {
             Assert.Empty(Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(100).ToArray());
         }
 
+        [Fact]
+        public void EmptyToList()
+        {
+            Assert.Empty(Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(100).ToList());
+        }
+
         [Fact]
         public void AttemptedMoreArray()
         {
             Assert.Equal(Enumerable.Range(0, 20), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Take(30).ToArray());
         }
 
+        [Fact]
+        public void AttemptedMoreToList()
+        {
+            Assert.Equal(Enumerable.Range(0, 20), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Take(30).ToList());
+        }
+
         [Fact]
         public void SingleElementToArray()
         {
             Assert.Equal(Enumerable.Repeat(10, 1), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Skip(10).Take(1).ToArray());
         }
 
+        [Fact]
+        public void SingleElementToList()
+        {
+            Assert.Equal(Enumerable.Repeat(10, 1), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Skip(10).Take(1).ToList());
+        }
+
         [Fact]
         public void EnumeratorDoesntContinue()
         {
@@ -327,5 +351,35 @@ public void EnumeratorDoesntContinue()
             while (enumerator.MoveNext()) { }
             Assert.False(enumerator.MoveNext());
         }
+
+        [Fact]
+        public void SubsetAfterSelect()
+        {
+            var page = Enumerable.Range(0, 50).Shuffle().OrderBy(i => i).Select(i => i * 2).Skip(20).Take(5);
+            Assert.Equal(new[] { 40, 42, 44, 46, 48 }, page);
+            Assert.Equal(new[] { 41, 43, 45, 47, 49 }, page.Select(i => i + 1));
+            Assert.Equal(40, page.First());
+            Assert.Equal(48, page.Last());
+            Assert.Equal(42, page.ElementAt(1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => page.ElementAt(20));
+            page = Enumerable.Range(0, 50).Shuffle().OrderBy(i => i).Select(i => i * 2).Skip(100).Take(5);
+            Assert.Throws<InvalidOperationException>(() => page.First());
+            Assert.Throws<InvalidOperationException>(() => page.Last());
+        }
+
+        [Fact]
+        public void SubsetAfterSelectEnumeratorDoesntContinue()
+        {
+            var enumerator = NumberRangeGuaranteedNotCollectionType(0, 3).Shuffle().OrderBy(i => i).Select(i => i * 2).Take(1).GetEnumerator();
+            while (enumerator.MoveNext()) { }
+            Assert.False(enumerator.MoveNext());
+        }
+
+        [Fact]
+        public void SubsetAfterSelectRepeatEnumerating()
+        {
+            var page = NumberRangeGuaranteedNotCollectionType(0, 3).Shuffle().OrderBy(i => i).Select(i => i * 2).Take(1);
+            Assert.Equal(page, page);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/System.Linq/tests/ReverseTests.cs b/src/System.Linq/tests/ReverseTests.cs
index d61bd7557b8f..8aceb80fe497 100644
--- a/src/System.Linq/tests/ReverseTests.cs
+++ b/src/System.Linq/tests/ReverseTests.cs
@@ -77,5 +77,31 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void ToArray()
+        {
+            int?[] source = new int?[] { -10, 0, 5, null, 0, 9, 100, null, 9 };
+            int?[] expected = new int?[] { 9, null, 100, 9, 0, null, 5, 0, -10 };
+
+            Assert.Equal(expected, source.Reverse().ToArray());
+        }
+
+        [Fact]
+        public void ToList()
+        {
+            int?[] source = new int?[] { -10, 0, 5, null, 0, 9, 100, null, 9 };
+            int?[] expected = new int?[] { 9, null, 100, 9, 0, null, 5, 0, -10 };
+
+            Assert.Equal(expected, source.Reverse().ToList());
+        }
+
+        [Fact]
+        public void RepeatEnumerating()
+        {
+            var reversed = new int?[] { -10, 0, 5, null, 0, 9, 100, null, 9 }.Reverse();
+
+            Assert.Equal(reversed, reversed);
+        }
     }
 }
diff --git a/src/System.Linq/tests/SkipTests.cs b/src/System.Linq/tests/SkipTests.cs
index a49570be9015..5bb6889bafb9 100644
--- a/src/System.Linq/tests/SkipTests.cs
+++ b/src/System.Linq/tests/SkipTests.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -213,5 +214,258 @@ public void ForcedToEnumeratorDoesntEnumerateIList()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void FollowWithTake()
+        {
+            var source = new[] { 5, 6, 7, 8 };
+            var expected = new[] { 6, 7 };
+            Assert.Equal(expected, source.Skip(1).Take(2));
+        }
+
+        [Fact]
+        public void FollowWithTakeNotIList()
+        {
+            var source = NumberRangeGuaranteedNotCollectionType(5, 4);
+            var expected = new[] { 6, 7 };
+            Assert.Equal(expected, source.Skip(1).Take(2));
+        }
+
+        [Fact]
+        public void FollowWithSkip()
+        {
+            var source = new[] { 1, 2, 3, 4, 5, 6 };
+            var expected = new[] { 4, 5, 6 };
+            Assert.Equal(expected, source.Skip(1).Skip(2).Skip(-4));
+        }
+
+        [Fact]
+        public void FollowWithSkipNotIList()
+        {
+            var source = NumberRangeGuaranteedNotCollectionType(1, 6);
+            var expected = new[] { 4, 5, 6 };
+            Assert.Equal(expected, source.Skip(1).Skip(2).Skip(-4));
+        }
+
+        [Fact]
+        public void ElementAt()
+        {
+            var source = new[] { 1, 2, 3, 4, 5, 6 };
+            var remaining = source.Skip(2);
+            Assert.Equal(3, remaining.ElementAt(0));
+            Assert.Equal(4, remaining.ElementAt(1));
+            Assert.Equal(6, remaining.ElementAt(3));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => remaining.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => remaining.ElementAt(4));
+        }
+
+        [Fact]
+        public void ElementAtNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5, 6 });
+            var remaining = source.Skip(2);
+            Assert.Equal(3, remaining.ElementAt(0));
+            Assert.Equal(4, remaining.ElementAt(1));
+            Assert.Equal(6, remaining.ElementAt(3));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => remaining.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => remaining.ElementAt(4));
+        }
+
+        [Fact]
+        public void ElementAtOrDefault()
+        {
+            var source = new[] { 1, 2, 3, 4, 5, 6 };
+            var remaining = source.Skip(2);
+            Assert.Equal(3, remaining.ElementAtOrDefault(0));
+            Assert.Equal(4, remaining.ElementAtOrDefault(1));
+            Assert.Equal(6, remaining.ElementAtOrDefault(3));
+            Assert.Equal(0, remaining.ElementAtOrDefault(-1));
+            Assert.Equal(0, remaining.ElementAtOrDefault(4));
+        }
+
+        [Fact]
+        public void ElementAtOrDefaultNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5, 6 });
+            var remaining = source.Skip(2);
+            Assert.Equal(3, remaining.ElementAtOrDefault(0));
+            Assert.Equal(4, remaining.ElementAtOrDefault(1));
+            Assert.Equal(6, remaining.ElementAtOrDefault(3));
+            Assert.Equal(0, remaining.ElementAtOrDefault(-1));
+            Assert.Equal(0, remaining.ElementAtOrDefault(4));
+        }
+
+        [Fact]
+        public void First()
+        {
+            var source = new []{ 1, 2, 3, 4, 5 };
+            Assert.Equal(1, source.Skip(0).First());
+            Assert.Equal(3, source.Skip(2).First());
+            Assert.Equal(5, source.Skip(4).First());
+            Assert.Throws<InvalidOperationException>(() => source.Skip(5).First());
+        }
+
+        [Fact]
+        public void FirstNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(1, source.Skip(0).First());
+            Assert.Equal(3, source.Skip(2).First());
+            Assert.Equal(5, source.Skip(4).First());
+            Assert.Throws<InvalidOperationException>(() => source.Skip(5).First());
+        }
+
+        [Fact]
+        public void FirstOrDefault()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(1, source.Skip(0).FirstOrDefault());
+            Assert.Equal(3, source.Skip(2).FirstOrDefault());
+            Assert.Equal(5, source.Skip(4).FirstOrDefault());
+            Assert.Equal(0, source.Skip(5).FirstOrDefault());
+        }
+
+        [Fact]
+        public void FirstOrDefaultNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(1, source.Skip(0).FirstOrDefault());
+            Assert.Equal(3, source.Skip(2).FirstOrDefault());
+            Assert.Equal(5, source.Skip(4).FirstOrDefault());
+            Assert.Equal(0, source.Skip(5).FirstOrDefault());
+        }
+
+        [Fact]
+        public void Last()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(5, source.Skip(0).Last());
+            Assert.Equal(5, source.Skip(1).Last());
+            Assert.Equal(5, source.Skip(4).Last());
+            Assert.Throws<InvalidOperationException>(() => source.Skip(5).Last());
+        }
+
+        [Fact]
+        public void LastNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(5, source.Skip(0).Last());
+            Assert.Equal(5, source.Skip(1).Last());
+            Assert.Equal(5, source.Skip(4).Last());
+            Assert.Throws<InvalidOperationException>(() => source.Skip(5).Last());
+        }
+
+        [Fact]
+        public void LastOrDefault()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(5, source.Skip(0).LastOrDefault());
+            Assert.Equal(5, source.Skip(1).LastOrDefault());
+            Assert.Equal(5, source.Skip(4).LastOrDefault());
+            Assert.Equal(0, source.Skip(5).LastOrDefault());
+        }
+
+        [Fact]
+        public void LastOrDefaultNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(5, source.Skip(0).LastOrDefault());
+            Assert.Equal(5, source.Skip(1).LastOrDefault());
+            Assert.Equal(5, source.Skip(4).LastOrDefault());
+            Assert.Equal(0, source.Skip(5).LastOrDefault());
+        }
+
+        [Fact]
+        public void ToArray()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Skip(0).ToArray());
+            Assert.Equal(new[] { 2, 3, 4, 5 }, source.Skip(1).ToArray());
+            Assert.Equal(5, source.Skip(4).ToArray().Single());
+            Assert.Empty(source.Skip(5).ToArray());
+            Assert.Empty(source.Skip(40).ToArray());
+        }
+
+        [Fact]
+        public void ToArrayNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Skip(0).ToArray());
+            Assert.Equal(new[] { 2, 3, 4, 5 }, source.Skip(1).ToArray());
+            Assert.Equal(5, source.Skip(4).ToArray().Single());
+            Assert.Empty(source.Skip(5).ToArray());
+            Assert.Empty(source.Skip(40).ToArray());
+        }
+
+        [Fact]
+        public void ToList()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Skip(0).ToList());
+            Assert.Equal(new[] { 2, 3, 4, 5 }, source.Skip(1).ToList());
+            Assert.Equal(5, source.Skip(4).ToList().Single());
+            Assert.Empty(source.Skip(5).ToList());
+            Assert.Empty(source.Skip(40).ToList());
+        }
+
+        [Fact]
+        public void ToListNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Skip(0).ToList());
+            Assert.Equal(new[] { 2, 3, 4, 5 }, source.Skip(1).ToList());
+            Assert.Equal(5, source.Skip(4).ToList().Single());
+            Assert.Empty(source.Skip(5).ToList());
+            Assert.Empty(source.Skip(40).ToList());
+        }
+
+        [Fact]
+        public void RepeatEnumerating()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            var remaining = source.Skip(1);
+            Assert.Equal(remaining, remaining);
+        }
+
+        [Fact]
+        public void RepeatEnumeratingNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            var remaining = source.Skip(1);
+            Assert.Equal(remaining, remaining);
+        }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.Select(i => i * 2);
+            Assert.Equal(new[] { 6, 8 }, source.Skip(2));
+            Assert.Empty(source.Skip(4));
+            Assert.Empty(source.Skip(20));
+            Assert.Equal(source, source.Skip(0));
+            Assert.Equal(source, source.Skip(-1));
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.ToList().Select(i => i * 2);
+            Assert.Equal(new[] { 6, 8 }, source.Skip(2));
+            Assert.Empty(source.Skip(4));
+            Assert.Empty(source.Skip(20));
+            Assert.Equal(source, source.Skip(0));
+            Assert.Equal(source, source.Skip(-1));
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            var source = new ReadOnlyCollection<int>(new[] { 1, 2, 3, 4 }).Select(i => i * 2);
+            Assert.Equal(new[] { 6, 8 }, source.Skip(2));
+            Assert.Empty(source.Skip(4));
+            Assert.Empty(source.Skip(20));
+            Assert.Equal(source, source.Skip(0));
+            Assert.Equal(source, source.Skip(-1));
+        }
     }
 }
diff --git a/src/System.Linq/tests/TakeTests.cs b/src/System.Linq/tests/TakeTests.cs
index e767a74dadbd..36d65813a4f7 100644
--- a/src/System.Linq/tests/TakeTests.cs
+++ b/src/System.Linq/tests/TakeTests.cs
@@ -3,12 +3,19 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
 {
     public class TakeTests : EnumerableTests
     {
+        private static IEnumerable<T> GuaranteeNotIList<T>(IEnumerable<T> source)
+        {
+            foreach (T element in source)
+                yield return element;
+        }
+
         [Fact]
         public void SameResultsRepeatCallsIntQuery()
         {
@@ -19,6 +26,16 @@ where x > Int32.MinValue
             Assert.Equal(q.Take(9), q.Take(9));
         }
 
+        [Fact]
+        public void SameResultsRepeatCallsIntQueryIList()
+        {
+            var q = (from x in new[] { 9999, 0, 888, -1, 66, -777, 1, 2, -12345 }
+                     where x > Int32.MinValue
+                     select x).ToList();
+
+            Assert.Equal(q.Take(9), q.Take(9));
+        }
+
         [Fact]
         public void SameResultsRepeatCallsStringQuery()
         {
@@ -29,6 +46,16 @@ public void SameResultsRepeatCallsStringQuery()
             Assert.Equal(q.Take(7), q.Take(7));
         }
 
+        [Fact]
+        public void SameResultsRepeatCallsStringQueryIList()
+        {
+            var q = (from x in new[] { "!@#$%^", "C", "AAA", "", "Calling Twice", "SoS", String.Empty }
+                     where !String.IsNullOrEmpty(x)
+                     select x).ToList();
+
+            Assert.Equal(q.Take(7), q.Take(7));
+        }
+
         [Fact]
         public void SourceEmptyCountPositive()
         {
@@ -36,6 +63,13 @@ public void SourceEmptyCountPositive()
             Assert.Empty(source.Take(5));
         }
 
+        [Fact]
+        public void SourceEmptyCountPositiveNotIList()
+        {
+            var source = NumberRangeGuaranteedNotCollectionType(0, 0);
+            Assert.Empty(source.Take(5));
+        }
+
         [Fact]
         public void SourceNonEmptyCountNegative()
         {
@@ -43,6 +77,13 @@ public void SourceNonEmptyCountNegative()
             Assert.Empty(source.Take(-5));
         }
 
+        [Fact]
+        public void SourceNonEmptyCountNegativeNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 2, 5, 9, 1 });
+            Assert.Empty(source.Take(-5));
+        }
+
         [Fact]
         public void SourceNonEmptyCountZero()
         {
@@ -50,6 +91,13 @@ public void SourceNonEmptyCountZero()
             Assert.Empty(source.Take(0));
         }
 
+        [Fact]
+        public void SourceNonEmptyCountZeroNotIList()
+        {
+            var source = GuaranteeNotIList(new []{ 2, 5, 9, 1 });
+            Assert.Empty(source.Take(0));
+        }
+
         [Fact]
         public void SourceNonEmptyCountOne()
         {
@@ -59,14 +107,31 @@ public void SourceNonEmptyCountOne()
             Assert.Equal(expected, source.Take(1));
         }
 
+        [Fact]
+        public void SourceNonEmptyCountOneNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 2, 5, 9, 1 });
+            int[] expected = { 2 };
+
+            Assert.Equal(expected, source.Take(1));
+        }
+
         [Fact]
         public void SourceNonEmptyTakeAllExactly()
         {
             int[] source = { 2, 5, 9, 1 };
-            
+
             Assert.Equal(source, source.Take(source.Length));
         }
 
+        [Fact]
+        public void SourceNonEmptyTakeAllExactlyNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 2, 5, 9, 1 });
+
+            Assert.Equal(source, source.Take(source.Count()));
+        }
+
         [Fact]
         public void SourceNonEmptyTakeAllButOne()
         {
@@ -76,6 +141,15 @@ public void SourceNonEmptyTakeAllButOne()
             Assert.Equal(expected, source.Take(3));
         }
 
+        [Fact]
+        public void SourceNonEmptyTakeAllButOneNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 2, 5, 9, 1 });
+            int[] expected = { 2, 5, 9 };
+
+            Assert.Equal(expected, source.Take(3));
+        }
+
         [Fact]
         public void SourceNonEmptyTakeExcessive()
         {
@@ -83,7 +157,15 @@ public void SourceNonEmptyTakeExcessive()
 
             Assert.Equal(source, source.Take(source.Length + 1));
         }
-        
+
+        [Fact]
+        public void SourceNonEmptyTakeExcessiveNotIList()
+        {
+            var source = GuaranteeNotIList(new int?[] { 2, 5, null, 9, 1 });
+
+            Assert.Equal(source, source.Take(source.Count() + 1));
+        }
+
         [Fact]
         public void ThrowsOnNullSource()
         {
@@ -99,5 +181,275 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void ForcedToEnumeratorDoesntEnumerateIList()
+        {
+            var iterator = NumberRangeGuaranteedNotCollectionType(0, 3).ToList().Take(2);
+            // Don't insist on this behaviour, but check its correct if it happens
+            var en = iterator as IEnumerator<int>;
+            Assert.False(en != null && en.MoveNext());
+        }
+
+        [Fact]
+        public void FollowWithTake()
+        {
+            var source = new[] { 5, 6, 7, 8 };
+            var expected = new[] { 5, 6 };
+            Assert.Equal(expected, source.Take(5).Take(3).Take(2).Take(40));
+        }
+
+        [Fact]
+        public void FollowWithTakeNotIList()
+        {
+            var source = NumberRangeGuaranteedNotCollectionType(5, 4);
+            var expected = new[] { 5, 6 };
+            Assert.Equal(expected, source.Take(5).Take(3).Take(2));
+        }
+
+        [Fact]
+        public void FollowWithSkip()
+        {
+            var source = new[] { 1, 2, 3, 4, 5, 6 };
+            var expected = new[] { 3, 4, 5 };
+            Assert.Equal(expected, source.Take(5).Skip(2).Skip(-4));
+        }
+
+        [Fact]
+        public void FollowWithSkipNotIList()
+        {
+            var source = NumberRangeGuaranteedNotCollectionType(1, 6);
+            var expected = new[] { 3, 4, 5 };
+            Assert.Equal(expected, source.Take(5).Skip(2).Skip(-4));
+        }
+
+        [Fact]
+        public void ElementAt()
+        {
+            var source = new[] { 1, 2, 3, 4, 5, 6 };
+            var taken = source.Take(3);
+            Assert.Equal(1, taken.ElementAt(0));
+            Assert.Equal(3, taken.ElementAt(2));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => taken.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => taken.ElementAt(3));
+        }
+
+        [Fact]
+        public void ElementAtNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5, 6 });
+            var taken = source.Take(3);
+            Assert.Equal(1, taken.ElementAt(0));
+            Assert.Equal(3, taken.ElementAt(2));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => taken.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => taken.ElementAt(3));
+        }
+
+        [Fact]
+        public void ElementAtOrDefault()
+        {
+            var source = new[] { 1, 2, 3, 4, 5, 6 };
+            var taken = source.Take(3);
+            Assert.Equal(1, taken.ElementAtOrDefault(0));
+            Assert.Equal(3, taken.ElementAtOrDefault(2));
+            Assert.Equal(0, taken.ElementAtOrDefault(-1));
+            Assert.Equal(0, taken.ElementAtOrDefault(3));
+        }
+
+        [Fact]
+        public void ElementAtOrDefaultNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5, 6 });
+            var taken = source.Take(3);
+            Assert.Equal(1, taken.ElementAtOrDefault(0));
+            Assert.Equal(3, taken.ElementAtOrDefault(2));
+            Assert.Equal(0, taken.ElementAtOrDefault(-1));
+            Assert.Equal(0, taken.ElementAtOrDefault(3));
+        }
+
+        [Fact]
+        public void First()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(1, source.Take(1).First());
+            Assert.Equal(1, source.Take(4).First());
+            Assert.Equal(1, source.Take(40).First());
+            Assert.Throws<InvalidOperationException>(() => source.Take(0).First());
+            Assert.Throws<InvalidOperationException>(() => source.Skip(5).Take(10).First());
+        }
+
+        [Fact]
+        public void FirstNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(1, source.Take(1).First());
+            Assert.Equal(1, source.Take(4).First());
+            Assert.Equal(1, source.Take(40).First());
+            Assert.Throws<InvalidOperationException>(() => source.Take(0).First());
+            Assert.Throws<InvalidOperationException>(() => source.Skip(5).Take(10).First());
+        }
+
+        [Fact]
+        public void FirstOrDefault()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(1, source.Take(1).FirstOrDefault());
+            Assert.Equal(1, source.Take(4).FirstOrDefault());
+            Assert.Equal(1, source.Take(40).FirstOrDefault());
+            Assert.Equal(0, source.Take(0).FirstOrDefault());
+            Assert.Equal(0, source.Skip(5).Take(10).FirstOrDefault());
+        }
+
+        [Fact]
+        public void FirstOrDefaultNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(1, source.Take(1).FirstOrDefault());
+            Assert.Equal(1, source.Take(4).FirstOrDefault());
+            Assert.Equal(1, source.Take(40).FirstOrDefault());
+            Assert.Equal(0, source.Take(0).FirstOrDefault());
+            Assert.Equal(0, source.Skip(5).Take(10).FirstOrDefault());
+        }
+
+        [Fact]
+        public void Last()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(1, source.Take(1).Last());
+            Assert.Equal(5, source.Take(5).Last());
+            Assert.Equal(5, source.Take(40).Last());
+            Assert.Throws<InvalidOperationException>(() => source.Take(0).Last());
+            Assert.Throws<InvalidOperationException>(() => Array.Empty<int>().Take(40).Last());
+        }
+
+        [Fact]
+        public void LastNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(1, source.Take(1).Last());
+            Assert.Equal(5, source.Take(5).Last());
+            Assert.Equal(5, source.Take(40).Last());
+            Assert.Throws<InvalidOperationException>(() => source.Take(0).Last());
+            Assert.Throws<InvalidOperationException>(() => GuaranteeNotIList(Array.Empty<int>()).Take(40).Last());
+        }
+
+        [Fact]
+        public void LastOrDefault()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(1, source.Take(1).LastOrDefault());
+            Assert.Equal(5, source.Take(5).LastOrDefault());
+            Assert.Equal(5, source.Take(40).LastOrDefault());
+            Assert.Equal(0, source.Take(0).LastOrDefault());
+            Assert.Equal(0, Array.Empty<int>().Take(40).LastOrDefault());
+        }
+
+        [Fact]
+        public void LastOrDefaultNotIList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(1, source.Take(1).LastOrDefault());
+            Assert.Equal(5, source.Take(5).LastOrDefault());
+            Assert.Equal(5, source.Take(40).LastOrDefault());
+            Assert.Equal(0, source.Take(0).LastOrDefault());
+            Assert.Equal(0, GuaranteeNotIList(Array.Empty<int>()).Take(40).LastOrDefault());
+        }
+
+        [Fact]
+        public void ToArray()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(5).ToArray());
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(40).ToArray());
+            Assert.Equal(new[] { 1, 2, 3, 4 }, source.Take(4).ToArray());
+            Assert.Equal(1, source.Take(1).ToArray().Single());
+            Assert.Empty(source.Take(0).ToArray());
+            Assert.Empty(source.Take(-10).ToArray());
+        }
+
+        [Fact]
+        public void ToArrayNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(5).ToArray());
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(40).ToArray());
+            Assert.Equal(new[] { 1, 2, 3, 4 }, source.Take(4).ToArray());
+            Assert.Equal(1, source.Take(1).ToArray().Single());
+            Assert.Empty(source.Take(0).ToArray());
+            Assert.Empty(source.Take(-10).ToArray());
+        }
+
+        [Fact]
+        public void ToList()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(5).ToList());
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(40).ToList());
+            Assert.Equal(new[] { 1, 2, 3, 4 }, source.Take(4).ToList());
+            Assert.Equal(1, source.Take(1).ToList().Single());
+            Assert.Empty(source.Take(0).ToList());
+            Assert.Empty(source.Take(-10).ToList());
+        }
+
+        [Fact]
+        public void ToListNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(5).ToList());
+            Assert.Equal(new[] { 1, 2, 3, 4, 5 }, source.Take(40).ToList());
+            Assert.Equal(new[] { 1, 2, 3, 4 }, source.Take(4).ToList());
+            Assert.Equal(1, source.Take(1).ToList().Single());
+            Assert.Empty(source.Take(0).ToList());
+            Assert.Empty(source.Take(-10).ToList());
+        }
+
+        [Fact]
+        public void RepeatEnumerating()
+        {
+            var source = new[] { 1, 2, 3, 4, 5 };
+            var taken = source.Take(3);
+            Assert.Equal(taken, taken);
+        }
+
+        [Fact]
+        public void RepeatEnumeratingNotList()
+        {
+            var source = GuaranteeNotIList(new[] { 1, 2, 3, 4, 5 });
+            var taken = source.Take(3);
+            Assert.Equal(taken, taken);
+        }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.Select(i => i * 2);
+            Assert.Equal(new[] { 2, 4 }, source.Take(2));
+            Assert.Empty(source.Take(0));
+            Assert.Empty(source.Take(-20));
+            Assert.Equal(source, source.Take(4));
+            Assert.Equal(source, source.Take(40));
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.ToList().Select(i => i * 2);
+            Assert.Equal(new[] { 2, 4 }, source.Take(2));
+            Assert.Empty(source.Take(0));
+            Assert.Empty(source.Take(-20));
+            Assert.Equal(source, source.Take(4));
+            Assert.Equal(source, source.Take(40));
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            var source = new ReadOnlyCollection<int>(new[] { 1, 2, 3, 4 }).Select(i => i * 2);
+            Assert.Equal(new[] { 2, 4 }, source.Take(2));
+            Assert.Empty(source.Take(0));
+            Assert.Empty(source.Take(-20));
+            Assert.Equal(source, source.Take(4));
+            Assert.Equal(source, source.Take(40));
+        }
     }
 }
diff --git a/src/System.Linq/tests/UnionTests.cs b/src/System.Linq/tests/UnionTests.cs
index 6decc34defba..b16143d90647 100644
--- a/src/System.Linq/tests/UnionTests.cs
+++ b/src/System.Linq/tests/UnionTests.cs
@@ -205,5 +205,36 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void ToArray()
+        {
+            string[] first = { "Bob", "Robert", "Tim", "Matt", "miT" };
+            string[] second = { "ttaM", "Charlie", "Bbo" };
+            string[] expected = { "Bob", "Robert", "Tim", "Matt", "miT", "ttaM", "Charlie", "Bbo" };
+
+            Assert.Equal(expected, first.Union(second).ToArray());
+        }
+
+        [Fact]
+        public void ToList()
+        {
+            string[] first = { "Bob", "Robert", "Tim", "Matt", "miT" };
+            string[] second = { "ttaM", "Charlie", "Bbo" };
+            string[] expected = { "Bob", "Robert", "Tim", "Matt", "miT", "ttaM", "Charlie", "Bbo" };
+
+            Assert.Equal(expected, first.Union(second).ToList());
+        }
+
+        [Fact]
+        public void RepeatEnumerating()
+        {
+            string[] first = { "Bob", "Robert", "Tim", "Matt", "miT" };
+            string[] second = { "ttaM", "Charlie", "Bbo" };
+
+            var result = first.Union(second);
+
+            Assert.Equal(result, result);
+        }
     }
 }