Batch should return IEnumerable<T[]>

[atifaziz]

Since batches are about splitting an IEnumerable into fixed sizes, every batch should know how many items it has, in addition to the original order of the source enumerable. Size + order preservation = IList.

This should break little (if any) existing code, because IList inherits IEnumerable. Asides from the signature, the only code change that needs to be made is for the underlying bucket store to be a List instead of an Array (which is the more LINQy approach anyways).

---

Originally reported on Google Code with ID 98

Reported by @Arithmomaniac on 2015-03-09 14:19:50

[atifaziz]

Or at least IReadOnlyCollection.

---

Reported by @Arithmomaniac on 2015-05-27 13:54:17

[fsateler]

This looks reasonable to me (after all the length is known beforehand). However, if done it should be done for 2.0, or else for the next major version as that signature change would break the ABI.

[atifaziz]

I would argue that even returning a sequence of arrays might be best here, which is required, could then be cast to an IList<T> or wrapped into a read-only collection. And while we're on the topic of buffered views, the same could apply to Windowed and Partition.

[atifaziz]

every batch should know how many items it has

Every batch will be the same size except the last one if the source sequence doesn't have a total count of elements that's a multiple of the requested size.

Size + order preservation = IList.

Batch does not mandate order preservation & the signature currently reflects that. If batching is tomorrow implemented in a parallel scatter-gather fashion then it just needs to stream batches but requiring order preservation could pin implementations to being less efficient than they could be.

in addition to the original order of the source enumerable.

This is almost the case with most LINQ operators yet they don't return IList<T>. You'd think, for example, that something as simple as Select would preserve order but it doesn't when using Parallel LINQ (see “Order Preservation in PLINQ”):

In PLINQ, the goal is to maximize performance while maintaining correctness. A query should run as fast as possible but still produce the correct results. In some cases, correctness requires the order of the source sequence to be preserved; however, ordering can be computationally expensive. Therefore, by default, PLINQ does not preserve the order of the source sequence. In this regard, PLINQ resembles LINQ to SQL, but is unlike LINQ to Objects, which does preserve ordering.

The signature of Batch is designed around minimum promises that need to be made but the MoreLINQ implementation is indeed buffered and order-preserving (delivers more than promised). And while I realize that you can't capture everything in a name, does Batch always evoke order? Something like Buffer does.

[atifaziz]

Considering that all but potentially the last batch will have the same size, I think it's fair to return a sequence of arrays. The signature will also be aligned with Chunk and allow just redirecting to it internally for a build targeting .NET 6+.