[Idea] Add FlattenStrategy.throttle

[inamiy]

Related to FlattenStrategy.race implemented in #233, I thought it will be useful to have FlattenStrategy.raceContinuous (or case race(continuous: Bool)) FlattenStrategy.throttleas well.

In theory, this will work similar to .flatMap(.merge) { someAPIAction.apply($0) } but omitting Action which may sometimes become too verbose to declare (if we aren't interested in enabledIf, isExecuting, etc).

Use case

Example: Loading next API after scrollView reached bottom

let reachedBottom = Signal<(), NoError>.pipe()  // let's say, scrollView triggers this
let nextPageProperty = MutableProperty<Int>(0) // state

let responses = reachedBottom.output
    .withLatest(from: nextPageProperty.producer)
    .flatMap(.throttle) { nextPage -> SignalProducer<Response, NoError>in
        return loadNext(nextPage) // some API request
            .flatMapError { _ in .empty } // ignore network error
    }

nextPageProperty <~ responses.map { $0.nextPage }

responses
    .observeCompleted { print("done!") }

// main

reachedBottom.input.send(value: ())
// 1st loadNext progressing...
reachedBottom.input.send(value: ())
// 1st loadNext still progressing, no 2nd loadNext

wait(1) // wait until API finished
// 1st loadNext completed

reachedBottom.input.send(value: ())
// 2nd loadNext progressing...
reachedBottom.input.send(value: ())
// 2nd loadNext still progressing, no 3rd loadNext

reachedBottom.input.sendCompleted()
// 2nd loadNext still progressing, no print "done" yet

wait(1) // wait until API finished
// 2nd loadNext completed, prints "done"

[inamiy]

Sorry, actually this is not race but rather FlattenStrategy.first a.k.a. flatMapFirst.

[andersio]

It seems throttle is the best fit verb for this, just that it throttles by progress rather than a minimum time interval.

[inamiy]

Right, case throttle sounds better name 😄

[mdiep]

This seems conceptually similar to concat except that the queue/buffer isn't infinite.

Maybe this?

public static func queue(limit: UInt) -> FlattenStrategy { … }

[inamiy]

@mdiep
Interesting!
Since static let concat = FlattenStrategy(kind: .concurrent(limit: 1)), it should probably be improved like this:

public static func concurrent(limit: UInt, queueCount: UInt) -> FlattenStrategy

so that more flexible flattening e.g. limit = 10 && queueCount = 5 will be possible (though I don't know who will ever use this!).

[RuiAAPeres]

Hello. 👋 Thanks for opening this issue. Due to inactivity, we will soft close the issue. If you feel that it should remain open, please let us know. 😄