System.Linq.Async - Please add Buffer/Chunk

[TonyValenti]

Please add a Buffer/Chunk equivalent to System.Linq.Async.

[quinmars]

The package System.Linq.Async contains only operators that have equivalents in System.Linq. Async variants for System.Interactive operators can be found in System.Interactive.Async:

https://github.com/dotnet/reactive/blob/main/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Buffer.cs

[FreeApophis]

I do not need to understand why reactive thought "Operators" would be a good word, but anyway:

Chunk will be part of System.Linq in .NET 6, and is already available: dotnet/runtime#27449

[SeanFarrow]

Is this available in a pre-release or nightly package, or do I need to build the source myself?
If a nightly package is available, what NuGet feed should be used?

[quinmars]

Chunk will be part of System.Linq in .NET 6, and is already available

Interesting, than it should also be added to System.Linq.Async, System.Linq.Async.Queryable, and System.Reactive.Linq (Observable and Qbservable).

[idg10]

As far as I can tell, .NET 6.0's Chunk does the same thing as one of the Buffer overloads. So if it's going to be added for System.Reactive.Linq (Observable and Qbservable) as @quinmars suggests, would that mean deprecating the relevant Buffer overload?

Or is it OK to have the same functionality available under two different names?

Or did I miss something? Is .NET 6.0's Chunk different in some meaningful way from the equivalent overload of Buffer:

public static IEnumerable<IList<TSource>> Buffer<TSource>(this IEnumerable<TSource> source, int count)

As far as I can tell, the only distinction between Chunk and the IEnumerable<T> flavour of Buffer is that Chunk doesn't offer the overload that supports skipping and overlapping.

So would hypothetical Observable and Qbservable versions of Chunk be the same, i.e.: a subset of what you can already do with Buffer? Or should Rx decide that Chunk is the new name for Buffer and just offer all the old options under the new name?

[WhatzGames]

What is the current status?

[HansOlavS]

Any update on this? I would love to have Chunk in this package and think it belongs here. Pretty please? 😊

[oliverjanik]

Seconding this, would you accept a PR?

Looks like someone beat me to it: #1756

[HowardvanRooijen]

There's a meeting tonight with the .NET Foundation about onboarding future maintainers... I'm hoping we can make an announcement soon.

[Thaina]

Hello, are there any result about the future of this system as of yet?

[quinmars]

First of all sorry for the late reply. Now that the project is regaining momentum, it's more fun to participate in discussions.

So would hypothetical Observable and Qbservable versions of Chunk be the same, i.e.: a subset of what you can already do with Buffer? Or should Rx decide that Chunk is the new name for Buffer and just offer all the old options under the new name?

In my opinion, there should be at least Òbservable.Chunk(). That would make Buffer on the first sight superfluid. But removing an operator that was there from the beginning, just for the sake of symmetry, may be a little bit unfriendly to all those people that are happily using this operator since a decade.

There is a way to a have both. The Buffer operator has a second dimension, that is the time. The time-based Buffer operator puts the elements into buckets of equal time length. That might be useful if you are implementing some kind of histogram. But most times when I thought about to use this operator, I actually wanted something different: preventing an event burst. So I didn't need all the empty buckets. What I was looking for is what supertopi on SO called BufferWhenAvailable. And that is actually what a time-based Chunk operator should do.

So if we add not just a count-based but also a time-base Chunk operator, that behave different, than I think it'd be ok to have some overlapping behavior in the count based case. The time based variant could also be useful for System.Interactive.Async.