How to make this publisher extension generic

Question

I have the following extension on a Publisher which allows me to paginate a URL request. I originally used this in a specific use case, where the Output of the publisher was of type CustomType.

extension Publisher where Output == CustomType,
                          Failure == Error {
  func paginate(pageIdPublisher: CurrentValueSubject<String?, Never>) -> AnyPublisher<[User], Never> {
    return self
      .handleEvents(receiveOutput: { response in
        if let maxId = response.pageId {
          pageIdPublisher.send(maxId)
        } else {
          pageIdPublisher.send(completion: .finished)
        }
      })
      .reduce([]) { allUsers, response in
        return response.users + allUsers
      }
      .catch { error in
        Just([])
      }
      .eraseToAnyPublisher()
  }
}

struct CustomType: Codable {
  let users: [User]
  let pageId: String?
}

This is called like this:

func loadItem() async throws -> [String] {
  let pageIdPublisher = CurrentValueSubject<String?, Never>(nil)

  return try await pageIdPublisher
    .flatMap { pageId in
      urlSession
        .publisher(
          for: .item(pageId: pageId),
          receiveOn: queue
        )
    }
    .paginate(pageIdPublisher: pageIdPublisher) // <- This part
    .singleOutput()
}

However, I now want to make it generic so that it can be used on any Output type, so long as it has a pageId and some kind of array.

I tried using a protocol Pageable like this:

protocol Pageable {
  associatedtype T

  var pageId: String? {get}
  var items: [T] {get}
}

But I can't use that with the extension because Output can't have be used with a protocol that contains an associatedType.

Is this possible?

You would be kinder to your potential helpers if you provided enough code to allow your example code to _compile_. — matt, Jan 03 '22 at 15:18

Sweeper · Accepted Answer · 2022-01-03T16:02:39.000

If you constrained the Output type with : to your Pageable protocol, and used Output.T for the returned publisher's output type, the paginate method should compile:

extension Publisher where Output: Pageable,
                          Failure == Error {
  func paginate(pageIdPublisher: CurrentValueSubject<String?, Never>) -> AnyPublisher<[Output.T], Never> {
   return self
     .handleEvents(receiveOutput: { response in
       if let maxId = response.pageId {
         pageIdPublisher.send(maxId)
       } else {
         pageIdPublisher.send(completion: .finished)
       }
     })
     .reduce([]) { allItems, response in
       return response.items + allItems
     }
     .catch { error in
       Just([])
     }
     .eraseToAnyPublisher()
  }
}

Another idea of making this more generic would be to constrain Output to be an Identifiable type, where ID is an optional, and provide an extra closure argument to specify the mapping from Output to the array:

extension Publisher where Output: Identifiable,
                          Failure == Error {
    func paginate<T, ID>(
        pageIdPublisher: CurrentValueSubject<Output.ID?, Never>,
        items: @escaping (Output) -> [T]
    )
        -> AnyPublisher<[T], Never>
        where Self.Output.ID == ID?
    {
        ...

    }
}

You would use response.id instead of response.pageId, and items(response) instead of response.items in the implementation. At the callsite, you would pass in \.users for the closure argument, for example.

The update you made to this was perfect! That solved another problem that I didn't even mention in the question. You're a rockstar, thank you so much. — Tometoyou, Jan 03 '22 at 17:08

How to make this publisher extension generic

1 Answers1