Effects and Publishers : how to return async Effect

[JeromeTonnelierOgury]

Hi everyone!

We finally had our subscription running since yesterday, and I'm stuck on a particular issue (Don't know if I made the right choise though). I'll keep looking at the videos, but if in the meantime, someone has a clue, I'm all ears :D

So basically, I have a reducer with a dependency that has various PassthroughSubjects (they are here to wrap an actual delegate into a more TCA friendly flow).

I'll keep my example of the Video framework.
So I have a VideoManager as follows (drop the DependecyKey part to ease the understanding)

struct VideoManager {
   func load()
   func show()
   let videoLoaded: PassthroughSubject<Void, Error>
   let videoShown: PassthroughSubject<Void, Error>
   let loadError: PassthroughSubject<Error, Error>
   let showError: PassthroughSubject<Error, Error>
   let managerError: PassthroughSubject<Error, Error>
}

Yes, it seems a bit weird to have some passthroughSubject for the errors, but the errors can come from various source, and I guess it was easier that way. I'll try to tackle that in the next refinement.

Now my Reducer would have everything to handle UI (Spinners, Buttons, ...).. One of the actions would be loadButtonTapped and here is where it all goes south.

case .loadButtonTapped:
      return .run { send in
         videoManager
            .videoLoaded
            .sink { _ in } receiveValue: { _ in
               Task {
                  await send(.changeState(.loaded))
               }
            }
            .store(in: &storage.cancellablles)
                                    
            videoManager
               .loadError
               .sink { _ in } receiveValue: { error in
                  Task {
                     await send(.error(error))
                  }
                }
                .store(in: &storage.cancellablles)
                                    
             do {
                try videoManager.loadVideo()
             } catch {
                await send(.error(error))
             }
          }.cancellable(id: VideoCancel.load)

but the await send has no effect inside the sink methods (which I guess makes sense)
What I wanted to achieve was, once the loadButtonTapped was fired :

1. Listen for the PassthroughSubject videoLoaded and when it succeeds, inform the reducer with a .changeState(.loaded)
2. Listen for the PassthroughSubject loadError and when it succeeds, inform the reducer with a .error(.error)
3. Fire the actual load method with a videoManager.load()

If someone can point me out some code that would use a Subject "return" value inside an Effect, it would be great.
Maybe AsyncStreams would be better than pure Combine stuff, but I guess it's doable to use a PassthroughSubject inside an Effect right ?

Thanks a lot for your help 🙏

[mbrandonw]

Hi @JeromeTonnelierOgury, there is a much simpler way to achieve what you want. It is possible to create an effect from a Combine publisher using the Effect.publisher static method.

So, instead of this (which btw, where does storage live?):

return .run { send in
  videoManager
    .videoLoaded
    .sink { _ in } receiveValue: { _ in
       Task {
          await send(.changeState(.loaded))
       }
    }
    .store(in: &storage.cancellablles)

…you can simply do this:

return .publisher {
  videoManager.videoLoaded
    .map { _ in .changeState(.loaded) }
}

And if you need to run multiple of these publishers you can merge them together, either as publishers:

return .publisher {
  videoManager.videoLoaded
    .map { _ in .changeState(.loaded) }
    .merge(
      with: videoManager.loadError
        .map(Action.error)
    )
}

…or you can even merge them as effects:

return .merge(
  videoManager.videoLoaded
    .map { _ in .changeState(.loaded) },
  videoManager.loadError
    .map(Action.error)
)

[JeromeTonnelierOgury]

Thx I'll give it a try 🙏

[JeromeTonnelierOgury]

I get this error for every PassthroughSubject used :-/
Cannot convert value of type 'Publishers.Map<PassthroughSubject<Void, any Error>, VideoViewFeature.Action>' to expected argument type 'EffectPublisher<VideoViewFeature.Action, Never>'

This is for every videoManager.videoLoaded.map { _ in .changeState(.loaded) }, line in the merge

[mbrandonw]

The error says exactly what is happening, and if you read the docs you will see that the publisher returned in Effect.publisher cannot have an error. The Failure type must be Never.

Why can videoLoaded emit errors if they aren't handled anywhere? You have a separate publisher for errors, so shouldn't videoLoaded be a Publisher<Void, Never>?

I also think you could massively clean up these publishers and actions by refactoring the VideoManager to have a single publisher that emits a kind of event enum:

struct VideoManager {
  func load()
  func show()
  let events: AnyPublisher<Event, Never>
  enum Event {
    case loaded
    case shown
    case error(VideoError)
    enum VideoError {
      case load
      case show
      case manager
    }
  }
}

[JeromeTonnelierOgury]

Wow, thanks for your help!
Indeed I cloud use some PassthroughSubject<Void, Never>, I like your solution indeed, much simpler. I'll give it a try
Again, thanks for your help ❤️

[JeromeTonnelierOgury]

It worked, and with indeed a small but nice improvement over the Event enum. Thanks a lot @mbrandonw 🙏