Combine framework third `collect` method - ios

Question

In the iOS 13 Combine framework, there are three collect operator methods. The first two are obvious but the third uses types I can't figure out.
collect(_:options:)
https://developer.apple.com/documentation/foundation/timer/timerpublisher/3329497-collect
func collect<S>(_ strategy: Publishers.TimeGroupingStrategy<S>,
options: S.SchedulerOptions? = nil)
-> Publishers.CollectByTime<Timer.TimerPublisher, S>
where S : Scheduler
Can anyone give an example of how one would call this method?

Answer 1

After some struggle, I came up with an example like this:
let t = Timer.publish(every: 0.4, on: .main, in: .default)
t
.scan(0) {prev,_ in prev+1}
.collect(.byTime(DispatchQueue.main, .seconds(1))) // *
.sink(receiveCompletion: {print($0)}) {print($0)}.store(in:&storage)
let cancellable = t.connect()
delay(3) { cancellable.cancel() }
(where storage is the usual Set<AnyCancellable> to keep the subscriber alive).
The output is:
[1, 2]
[3, 4, 5]
[6, 7]
So we are publishing a new number about every 0.4 seconds, but collect only does its thing every 1 second. Thus, the first two values arrive, publishing 1 and 2, and then collect does its thing, accumulates all the values that have arrived so far, and publishes them as an array, [1,2]. And so on. Every second, whatever has come down the pipeline so far is accumulated into an array and published as an array.

Answer 2

The two TimeGroupingStrategy mechanisms are published in that enum. As of iOS 13.3 there are still just two:
byTime
byTimeOrCount
In either case, the first two parameters are a scheduler upon which to run them (Immediate, DispatchQueue, Runloop, or OperationQueue), which is often just inferred by whatever you pass in. Along with the scheduler is a Stride - a time interval you specify - that the operator will buffer values over.
In the byTime, it will collect and buffer as many elements as it receives (using an unbounded amount of memory to do so) in the interval you specify. The byTimeOrCount will limit how many items get buffered to a specific count.
The two means of specifying these are:
let q = DispatchQueue(label: self.debugDescription)
publisher
.collect(.byTime(q, 1.0))
or
let q = DispatchQueue(label: self.debugDescription)
publisher
.collect(.byTimeOrCount(q, 1.0, 10))
These use a DispatchQueue, but you could just as easily use any of the other schedulers.
If you just pass in an Double for the stride, it takes that as a value in seconds.
In both cases, when the time (or count, if that version is specified) is elapsed, the operator will publish an array of the collected values to its subscribers in turn.