diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs
index c5c9186e7..a459ee2dd 100644
--- a/MoreLinq.Test/BatchTest.cs
+++ b/MoreLinq.Test/BatchTest.cs
@@ -23,18 +23,12 @@ namespace MoreLinq.Test
     [TestFixture]
     public class BatchTest
     {
-        [Test]
-        public void BatchZeroSize()
-        {
-            AssertThrowsArgument.OutOfRangeException("size",() =>
-                new object[0].Batch(0));
-        }
-
-        [Test]
-        public void BatchNegativeSize()
+        [TestCase(0)]
+        [TestCase(-1)]
+        public void BatchBadSize(int size)
         {
-            AssertThrowsArgument.OutOfRangeException("size",() =>
-                new object[0].Batch(-1));
+            AssertThrowsArgument.OutOfRangeException("size", () =>
+                new object[0].Batch(size));
         }
 
         [Test]
@@ -141,3 +135,259 @@ public void BatchEmptySource(SourceKind kind)
         }
     }
 }
+
+#if NETCOREAPP3_1_OR_GREATER
+
+namespace MoreLinq.Test
+{
+    using System;
+    using System.Buffers;
+    using System.Collections.Generic;
+    using MoreLinq.Experimental;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class BatchPoolTest
+    {
+        [TestCase(0)]
+        [TestCase(-1)]
+        public void BatchBadSize(int size)
+        {
+            AssertThrowsArgument.OutOfRangeException("size", () =>
+                new object[0].Batch(size, ArrayPool<object>.Shared,
+                                    BreakingFunc.Of<ICurrentBuffer<object>, IEnumerable<object>>(),
+                                    BreakingFunc.Of<IEnumerable<object>, object>()));
+        }
+
+        [Test]
+        public void BatchEvenlyDivisibleSequence()
+        {
+            using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9);
+            using var pool = new TestArrayPool<int>();
+
+            var result = input.Batch(3, pool, Enumerable.ToArray);
+
+            using var reader = result.Read();
+            reader.Read().AssertSequenceEqual(1, 2, 3);
+            reader.Read().AssertSequenceEqual(4, 5, 6);
+            reader.Read().AssertSequenceEqual(7, 8, 9);
+            reader.ReadEnd();
+        }
+
+        [Test]
+        public void BatchUnevenlyDivisibleSequence()
+        {
+            using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9);
+            using var pool = new TestArrayPool<int>();
+
+            var result = input.Batch(4, pool, Enumerable.ToArray);
+
+            using var reader = result.Read();
+            reader.Read().AssertSequenceEqual(1, 2, 3, 4);
+            reader.Read().AssertSequenceEqual(5, 6, 7, 8);
+            reader.Read().AssertSequenceEqual(9);
+            reader.ReadEnd();
+        }
+
+        [Test]
+        public void BatchIsLazy()
+        {
+            var input = new BreakingSequence<object>();
+            _ = input.Batch(1, ArrayPool<object>.Shared,
+                            BreakingFunc.Of<ICurrentBuffer<object>, IEnumerable<object>>(),
+                            BreakingFunc.Of<IEnumerable<object>, object>());
+        }
+
+        [TestCase(SourceKind.BreakingList        , 0)]
+        [TestCase(SourceKind.BreakingReadOnlyList, 0)]
+        [TestCase(SourceKind.BreakingList        , 1)]
+        [TestCase(SourceKind.BreakingReadOnlyList, 1)]
+        [TestCase(SourceKind.BreakingList        , 2)]
+        [TestCase(SourceKind.BreakingReadOnlyList, 2)]
+        public void BatchCollectionSmallerThanSize(SourceKind kind, int oversize)
+        {
+            var xs = new[] { 1, 2, 3, 4, 5 };
+            using var pool = new TestArrayPool<int>();
+
+            var result = xs.ToSourceKind(kind)
+                           .Batch(xs.Length + oversize, pool, Enumerable.ToArray);
+
+            using var reader = result.Read();
+            reader.Read().AssertSequenceEqual(1, 2, 3, 4, 5);
+            reader.ReadEnd();
+        }
+
+        [Test]
+        public void BatchReadOnlyCollectionSmallerThanSize()
+        {
+            var collection = ReadOnlyCollection.From(1, 2, 3, 4, 5);
+            using var pool = new TestArrayPool<int>();
+
+            var result = collection.Batch(collection.Count * 2, pool,
+                                          Enumerable.ToArray);
+
+            using var reader = result.Read();
+            reader.Read().AssertSequenceEqual(1, 2, 3, 4, 5);
+            reader.ReadEnd();
+        }
+
+        [TestCase(SourceKind.Sequence)]
+        [TestCase(SourceKind.BreakingList)]
+        [TestCase(SourceKind.BreakingReadOnlyList)]
+        [TestCase(SourceKind.BreakingReadOnlyCollection)]
+        [TestCase(SourceKind.BreakingCollection)]
+        public void BatchEmptySource(SourceKind kind)
+        {
+            using var pool = new TestArrayPool<int>();
+
+            var result = Enumerable.Empty<int>()
+                                   .ToSourceKind(kind)
+                                   .Batch(100, pool, Enumerable.ToArray);
+
+            Assert.That(result, Is.Empty);
+        }
+
+        [Test]
+        public void BatchFilterBucket()
+        {
+            const int scale = 2;
+            var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9);
+            using var pool = new TestArrayPool<int>();
+
+            var result = input.Batch(3, pool,
+                                     current => from n in current
+                                                where n % 2 == 0
+                                                select n * scale,
+                                     Enumerable.ToArray);
+
+            using var reader = result.Read();
+            reader.Read().AssertSequenceEqual(2 * scale);
+            reader.Read().AssertSequenceEqual(4 * scale, 6 * scale);
+            reader.Read().AssertSequenceEqual(8 * scale);
+            reader.ReadEnd();
+        }
+
+        [Test]
+        public void BatchSumBucket()
+        {
+            var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9);
+            using var pool = new TestArrayPool<int>();
+
+            var result = input.Batch(3, pool, Enumerable.Sum);
+
+            using var reader = result.Read();
+            Assert.That(reader.Read(), Is.EqualTo(1 + 2 + 3));
+            Assert.That(reader.Read(), Is.EqualTo(4 + 5 + 6));
+            Assert.That(reader.Read(), Is.EqualTo(7 + 8 + 9));
+            reader.ReadEnd();
+        }
+
+        /// <remarks>
+        /// This test does not exercise the intended usage!
+        /// </remarks>
+
+        [Test]
+        public void BatchUpdatesCurrentListInPlace()
+        {
+            var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9);
+            using var pool = new TestArrayPool<int>();
+
+            var result = input.Batch(4, pool, current => current, current => (ICurrentBuffer<int>)current);
+
+            using var reader = result.Read();
+            var current = reader.Read();
+            current.AssertSequenceEqual(1, 2, 3, 4);
+            _ = reader.Read();
+            current.AssertSequenceEqual(5, 6, 7, 8);
+            _ = reader.Read();
+            current.AssertSequenceEqual(9);
+
+            reader.ReadEnd();
+
+            Assert.That(current, Is.Empty);
+        }
+
+        [Test]
+        public void BatchCallsBucketSelectorBeforeIteratingSource()
+        {
+            var iterations = 0;
+            IEnumerable<int> Source()
+            {
+                iterations++;
+                yield break;
+            }
+
+            var input = Source();
+            using var pool = new TestArrayPool<int>();
+            var initIterations = -1;
+
+            var result = input.Batch(4, pool,
+                                     current =>
+                                     {
+                                         initIterations = iterations;
+                                         return current;
+                                     },
+                                     _ => 0);
+
+            using var enumerator = result.GetEnumerator();
+            Assert.That(enumerator.MoveNext(), Is.False);
+            Assert.That(initIterations, Is.Zero);
+        }
+
+        [Test]
+        public void BatchBucketSelectorCurrentList()
+        {
+            var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9);
+            using var pool = new TestArrayPool<int>();
+            int[] bucketSelectorItems = null;
+
+            var result = input.Batch(4, pool, current => bucketSelectorItems = current.ToArray(), _ => 0);
+
+            using var reader = result.Read();
+            _ = reader.Read();
+            Assert.That(bucketSelectorItems, Is.Not.Null);
+            Assert.That(bucketSelectorItems, Is.Empty);
+        }
+
+        /// <summary>
+        /// An <see cref="ArrayPool{T}"/> implementation for testing purposes that holds only
+        /// one array in the pool and ensures that it is returned when the pool is disposed.
+        /// </summary>
+
+        sealed class TestArrayPool<T> : ArrayPool<T>, IDisposable
+        {
+            T[] _pooledArray;
+            T[] _rentedArray;
+
+            public override T[] Rent(int minimumLength)
+            {
+                if (_pooledArray is null && _rentedArray is null)
+                    _pooledArray = new T[minimumLength * 2];
+
+                if (_pooledArray is null)
+                    throw new InvalidOperationException("The pool is exhausted.");
+
+                (_pooledArray, _rentedArray) = (null, _pooledArray);
+
+                return _rentedArray;
+            }
+
+            public override void Return(T[] array, bool clearArray = false)
+            {
+                if (_rentedArray is null)
+                    throw new InvalidOperationException("Cannot return when nothing has been rented from this pool.");
+
+                if (array != _rentedArray)
+                    throw new InvalidOperationException("Cannot return what has not been rented from this pool.");
+
+                _pooledArray = array;
+                _rentedArray = null;
+            }
+
+            public void Dispose() =>
+                Assert.That(_rentedArray, Is.Null);
+        }
+    }
+}
+
+#endif // NETCOREAPP3_1_OR_GREATER
diff --git a/MoreLinq/Experimental/Batch.cs b/MoreLinq/Experimental/Batch.cs
new file mode 100644
index 000000000..ae40954ff
--- /dev/null
+++ b/MoreLinq/Experimental/Batch.cs
@@ -0,0 +1,294 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2022 Atif Aziz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+#if !NO_BUFFERS
+
+namespace MoreLinq.Experimental
+{
+    using System;
+    using System.Buffers;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+
+    static partial class ExperimentalEnumerable
+    {
+        /// <summary>
+        /// Batches the source sequence into sized buckets using an array pool
+        /// to rent arrays to back each bucket and returns a sequence of
+        /// elements projected from each bucket.
+        /// </summary>
+        /// <typeparam name="TSource">
+        /// Type of elements in <paramref name="source"/> sequence.</typeparam>
+        /// <typeparam name="TResult">
+        /// Type of elements of the resulting sequence.
+        /// </typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="size">Size of buckets.</param>
+        /// <param name="pool">The pool used to rent the array for each bucket.</param>
+        /// <param name="resultSelector">A function that projects a result from
+        /// the current bucket.</param>
+        /// <returns>
+        /// A sequence whose elements are projected from each bucket (returned by
+        /// <paramref name="resultSelector"/>).
+        /// </returns>
+        /// <remarks>
+        /// <para>
+        /// This operator uses deferred execution and streams its results
+        /// (however, each bucket provided to <paramref name="resultSelector"/> is
+        /// buffered).</para>
+        /// <para>
+        /// <para>
+        /// Each bucket is backed by a rented array that may be at least
+        /// <paramref name="size"/> in length.
+        /// </para>
+        /// <para>
+        /// When more than one bucket is produced, all buckets except the last
+        /// is guaranteed to have <paramref name="size"/> elements. The last
+        /// bucket may be smaller depending on the remaining elements in the
+        /// <paramref name="source"/> sequence.</para>
+        /// Each bucket is pre-allocated to <paramref name="size"/> elements.
+        /// If <paramref name="size"/> is set to a very large value, e.g.
+        /// <see cref="int.MaxValue"/> to effectively disable batching by just
+        /// hoping for a single bucket, then it can lead to memory exhaustion
+        /// (<see cref="OutOfMemoryException"/>).
+        /// </para>
+        /// </remarks>
+
+        public static IEnumerable<TResult>
+            Batch<TSource, TResult>(this IEnumerable<TSource> source, int size,
+                                    ArrayPool<TSource> pool,
+                                    Func<ICurrentBuffer<TSource>, TResult> resultSelector)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (pool == null) throw new ArgumentNullException(nameof(pool));
+            if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return source.Batch(size, pool, current => current,
+                                current => resultSelector((ICurrentBuffer<TSource>)current));
+        }
+
+        /// <summary>
+        /// Batches the source sequence into sized buckets using an array pool
+        /// to rent arrays to back each bucket and returns a sequence of
+        /// elements projected from each bucket.
+        /// </summary>
+        /// <typeparam name="TSource">
+        /// Type of elements in <paramref name="source"/> sequence.</typeparam>
+        /// <typeparam name="TBucket">
+        /// Type of elements in the sequence returned by <paramref name="bucketProjectionSelector"/>.</typeparam>
+        /// <typeparam name="TResult">
+        /// Type of elements of the resulting sequence.
+        /// </typeparam>
+        /// <param name="source">The source sequence.</param>
+        /// <param name="size">Size of buckets.</param>
+        /// <param name="pool">The pool used to rent the array for each bucket.</param>
+        /// <param name="bucketProjectionSelector">A function that returns a
+        /// sequence projection to use for each bucket. It is called initially
+        /// before iterating over <paramref name="source"/>, but the resulting
+        /// projection is evaluated for each bucket. This has the same effect as
+        /// calling <paramref name="bucketProjectionSelector"/> for each bucket,
+        /// but allows initialization of the transformation to happen only once.
+        /// </param>
+        /// <param name="resultSelector">A function that projects a result from
+        /// the input sequence produced over a bucket.</param>
+        /// <returns>
+        /// A sequence whose elements are projected from each bucket (returned by
+        /// <paramref name="resultSelector"/>).
+        /// </returns>
+        /// <remarks>
+        /// <para>
+        /// This operator uses deferred execution and streams its results
+        /// (however, each bucket is buffered).</para>
+        /// <para>
+        /// <para>
+        /// Each bucket is backed by a rented array that may be at least
+        /// <paramref name="size"/> in length.
+        /// </para>
+        /// <para>
+        /// When more than one bucket is produced, all buckets except the last
+        /// is guaranteed to have <paramref name="size"/> elements. The last
+        /// bucket may be smaller depending on the remaining elements in the
+        /// <paramref name="source"/> sequence.</para>
+        /// Each bucket is pre-allocated to <paramref name="size"/> elements.
+        /// If <paramref name="size"/> is set to a very large value, e.g.
+        /// <see cref="int.MaxValue"/> to effectively disable batching by just
+        /// hoping for a single bucket, then it can lead to memory exhaustion
+        /// (<see cref="OutOfMemoryException"/>).
+        /// </para>
+        /// </remarks>
+
+        public static IEnumerable<TResult>
+            Batch<TSource, TBucket, TResult>(
+                this IEnumerable<TSource> source, int size, ArrayPool<TSource> pool,
+                Func<ICurrentBuffer<TSource>, IEnumerable<TBucket>> bucketProjectionSelector,
+                Func<IEnumerable<TBucket>, TResult> resultSelector)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (pool == null) throw new ArgumentNullException(nameof(pool));
+            if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+            if (bucketProjectionSelector == null) throw new ArgumentNullException(nameof(bucketProjectionSelector));
+            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));
+
+            return _(); IEnumerable<TResult> _()
+            {
+                using var batch = source.Batch(size, pool);
+                var bucket = bucketProjectionSelector(batch.CurrentBuffer);
+                while (batch.UpdateWithNext())
+                    yield return resultSelector(bucket);
+            }
+        }
+
+        static ICurrentBufferProvider<T>
+            Batch<T>(this IEnumerable<T> source, int size, ArrayPool<T> pool)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (pool == null) throw new ArgumentNullException(nameof(pool));
+            if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size));
+
+            ICurrentBufferProvider<T> Cursor(IEnumerator<(T[], int)> source) =>
+                new CurrentPoolArrayProvider<T>(source, pool);
+
+            switch (source)
+            {
+                case ICollection<T> { Count: 0 }:
+                {
+                    return Cursor(Enumerable.Empty <(T[], int)>().GetEnumerator());
+                }
+                case ICollection<T> collection when collection.Count <= size:
+                {
+                    var bucket = pool.Rent(collection.Count);
+                    collection.CopyTo(bucket, 0);
+                    return Cursor(MoreEnumerable.Return((bucket, collection.Count)).GetEnumerator());
+                }
+                case IReadOnlyCollection<T> { Count: 0 }:
+                {
+                    return Cursor(Enumerable.Empty <(T[], int)>().GetEnumerator());
+                }
+                case IReadOnlyList<T> list when list.Count <= size:
+                {
+                    return Cursor(_()); IEnumerator<(T[], int)> _()
+                    {
+                        var bucket = pool.Rent(list.Count);
+                        for (var i = 0; i < list.Count; i++)
+                            bucket[i] = list[i];
+                        yield return (bucket, list.Count);
+                    }
+                }
+                case IReadOnlyCollection<T> collection when collection.Count <= size:
+                {
+                    return Cursor(Batch(collection.Count));
+                }
+                default:
+                {
+                    return Cursor(Batch(size));
+                }
+            }
+
+            IEnumerator<(T[], int)> Batch(int size)
+            {
+                T[]? bucket = null;
+                var count = 0;
+
+                foreach (var item in source)
+                {
+                    bucket ??= pool.Rent(size);
+                    bucket[count++] = item;
+
+                    // The bucket is fully buffered before it's yielded
+                    if (count != size)
+                        continue;
+
+                    yield return (bucket, size);
+
+                    bucket = null;
+                    count = 0;
+                }
+
+                // Return the last bucket with all remaining elements
+                if (bucket is { } someBucket && count > 0)
+                    yield return (someBucket, count);
+            }
+        }
+
+        sealed class CurrentPoolArrayProvider<T> : CurrentBuffer<T>, ICurrentBufferProvider<T>
+        {
+            bool _rented;
+            T[] _array = Array.Empty<T>();
+            int _count;
+            IEnumerator<(T[], int)>? _rental;
+            ArrayPool<T>? _pool;
+
+            public CurrentPoolArrayProvider(IEnumerator<(T[], int)> rental, ArrayPool<T> pool) =>
+                (_rental, _pool) = (rental, pool);
+
+            ICurrentBuffer<T> ICurrentBufferProvider<T>.CurrentBuffer => this;
+
+            public bool UpdateWithNext()
+            {
+                if (_rental is { Current: var (array, _) } rental)
+                {
+                    Debug.Assert(_pool is not null);
+                    if (_rented)
+                    {
+                        _pool.Return(array);
+                        _rented = false;
+                    }
+
+                    if (!rental.MoveNext())
+                    {
+                        Dispose();
+                        return false;
+                    }
+
+                    _rented = true;
+                    (_array, _count) = rental.Current;
+                    return true;
+                }
+
+                return false;
+            }
+
+            public override int Count => _count;
+
+            public override T this[int index]
+            {
+                get => index >= 0 && index < Count ? _array[index] : throw new IndexOutOfRangeException();
+                set => throw new NotSupportedException();
+
+            }
+
+            public void Dispose()
+            {
+                if (_rental is { Current: var (array, _) } enumerator)
+                {
+                    Debug.Assert(_pool is not null);
+                    if (_rented)
+                        _pool.Return(array);
+                    enumerator.Dispose();
+                    _array = Array.Empty<T>();
+                    _count = 0;
+                    _rental = null;
+                    _pool = null;
+                }
+            }
+        }
+    }
+}
+
+#endif // !NO_BUFFERS
diff --git a/MoreLinq/Experimental/CurrentBuffer.cs b/MoreLinq/Experimental/CurrentBuffer.cs
new file mode 100644
index 000000000..e6cb526a1
--- /dev/null
+++ b/MoreLinq/Experimental/CurrentBuffer.cs
@@ -0,0 +1,107 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2022 Atif Aziz. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#endregion
+
+#if !NO_BUFFERS
+
+namespace MoreLinq.Experimental
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    /// <summary>
+    /// Represents a current buffered view of a larger result and which
+    /// is updated in-place (thus current) as it is moved through the overall
+    /// result.
+    /// </summary>
+    /// <typeparam name="T">Type of elements in the list.</typeparam>
+
+    public interface ICurrentBuffer<T> : IList<T> { }
+
+    /// <summary>
+    /// A provider of current buffer that updates it in-place.
+    /// </summary>
+    /// <typeparam name="T">Type of elements in the list.</typeparam>
+
+    interface ICurrentBufferProvider<T> : IDisposable
+    {
+        /// <summary>
+        /// Gets the current items of the list.
+        /// </summary>
+        /// <remarks>
+        /// The returned list is updated in-place when <see cref="UpdateWithNext"/>
+        /// is called.
+        /// </remarks>
+
+        ICurrentBuffer<T> CurrentBuffer { get; }
+
+        /// <summary>
+        /// Update this instance with the next set of elements from the source.
+        /// </summary>
+        /// <returns>
+        /// A Boolean that is <c>true</c> if this instance was updated with
+        /// new elements; otherwise <c>false</c> to indicate that the end of
+        /// the bucket source has been reached.
+        /// </returns>
+
+        bool UpdateWithNext();
+    }
+
+    abstract class CurrentBuffer<T> : ICurrentBuffer<T>
+    {
+        public abstract int Count { get; }
+        public abstract T this[int index] { get; set; }
+
+        public virtual bool IsReadOnly => false;
+
+        public virtual int IndexOf(T item)
+        {
+            var comparer = EqualityComparer<T>.Default;
+
+            for (var i = 0; i < Count; i++)
+            {
+                if (comparer.Equals(this[i], item))
+                    return i;
+            }
+
+            return -1;
+        }
+
+        public virtual bool Contains(T item) => IndexOf(item) >= 0;
+
+        public virtual void CopyTo(T[] array, int arrayIndex)
+        {
+            if (arrayIndex < 0) throw new ArgumentOutOfRangeException(nameof(arrayIndex), arrayIndex, null);
+            if (arrayIndex + Count > array.Length) throw new ArgumentException(null, nameof(arrayIndex));
+
+            for (int i = 0, j = arrayIndex; i < Count; i++, j++)
+                array[j] = this[i];
+        }
+
+        public virtual IEnumerator<T> GetEnumerator() => this.Take(Count).GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        void IList<T>.Insert(int index, T item) => throw new NotSupportedException();
+        void IList<T>.RemoveAt(int index) => throw new NotSupportedException();
+        void ICollection<T>.Add(T item) => throw new NotSupportedException();
+        void ICollection<T>.Clear() => throw new NotSupportedException();
+        bool ICollection<T>.Remove(T item) => throw new NotSupportedException();
+    }
+}
+
+#endif // !NO_BUFFERS
diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj
index 35e2e7c3f..f428cf3e3 100644
--- a/MoreLinq/MoreLinq.csproj
+++ b/MoreLinq/MoreLinq.csproj
@@ -119,7 +119,7 @@
     <NeutralLanguage>en-US</NeutralLanguage>
     <VersionPrefix>3.3.2</VersionPrefix>
     <Authors>MoreLINQ Developers.</Authors>
-    <TargetFrameworks>net451;netstandard1.0;netstandard2.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net451;netstandard1.0;netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
     <Nullable>enable</Nullable>
     <!-- Parallel build is disabled to avoid file locking issues during T4 code generation.
          See also: https://github.com/dotnet/msbuild/issues/2781 -->
@@ -192,8 +192,12 @@
     <DefineConstants>$(DefineConstants);MORELINQ</DefineConstants>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0' Or '$(TargetFramework)' == 'net451' ">
+    <DefineConstants>$(DefineConstants);NO_BUFFERS</DefineConstants>
+  </PropertyGroup>
+
   <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard1.0'">
-    <DefineConstants>$(DefineConstants);NO_SERIALIZATION_ATTRIBUTES;NO_EXCEPTION_SERIALIZATION;NO_TRACING;NO_COM;NO_ASYNC</DefineConstants>
+    <DefineConstants>$(DefineConstants);NO_BUFFERS;NO_SERIALIZATION_ATTRIBUTES;NO_EXCEPTION_SERIALIZATION;NO_TRACING;NO_COM;NO_ASYNC</DefineConstants>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard1.0'">
diff --git a/README.md b/README.md
index 420dc324d..0104175ee 100644
--- a/README.md
+++ b/README.md
@@ -141,7 +141,7 @@ the third-last element and so on.
 
 Batches the source sequence into sized buckets.
 
-This method has 2 overloads.
+This method has 4 overloads, 2 of which are experimental.
 
 ### Cartesian