ObservableType+Paging.swift

extension ObservableType where Element == Void {
    func pagenation<
        Token,
        Source: ObservableConvertibleType,
        PagingElement
        >(
        startWith token: Token,
        selector: @escaping (Token) throws -> Source
    ) -> Observable<(usedToken: Token, PagingElement)>
        where
        Source.Element == (Token, PagingElement)
    {
        Paging(parent: self.asObservable(), initialToken: token, selector: selector).asObservable()
    }
}

struct Paging<SourceSequence: ObservableConvertibleType, Token, PagingElement>: ObservableType
    where SourceSequence.Element == (Token, PagingElement)
{
    typealias Element = (usedToken: Token, PagingElement)

    let parent: Observable<Void>
    let initialToken: Token
    let selector: (Token) throws -> SourceSequence

    func subscribe<Observer>(_ observer: Observer) -> Disposable where Observer : ObserverType, Element == Observer.Element {
        var nextToken = initialToken
        return parent
            .flatMapFirst { [selector] _ -> Observable<Element> in
                let usingToken = nextToken
                return try selector(usingToken).asObservable()
                    .do(onNext: { newToken, element in
                        nextToken = newToken
                    })
                    .map { _, element -> Element in
                        (usedToken: usingToken, element)
                }
        }
        .subscribe(observer)
    }
}