Question about catchToEffect() deprecation

[WedgeSparda]

Hi, I'm migrating our code base to prerelease/1.0 and I'm not sure how to deal with this deprecation

'catchToEffect()' is deprecated: Iterate over 'Publisher.values' in an 'EffectTask.run', instead, or use 'EffectTask.publisher'.

My context is like this:

func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
  switch action {
    case .doSomething:
      return executeAPublisherThatCanFailAndReturnsVoid()
                   .receive(on: mainQueue)
                   .catchToEffect() // Getting warning here
                   .map { result in
                     switch result {
                     case .success:
                         return .handleSuccessEffect
                     case .failure:
                         return .handleErrorEffect
                     }
                   }
  ...
  }

I saw this other answer but couldn't figure out how to adapt it to my code.

How should approach this change?

Thanks.

[tgrapperon]

Hey @WedgeSparda! Maybe something like this:

return .run { send in 
  for try await value in executeAPublisherThatCanFailAndReturnsVoid().values {
    await send(.handleSuccessEffect)
  }
} catch { _, send in
  await send(.handleErrorEffect)
}

[tgrapperon]

If this this publisher only emits once, you can replace .run by .task and you produce actions instead of using send:

return .task {
  try await executeAPublisherThatCanFailAndReturnsVoid().values.first
  return .handleSuccessEffect
} catch { _ in
  return .handleErrorEffect
}

[WedgeSparda]

Thanks @tgrapperon but can't use values since we're targeting versions prior to iOS 15.0

[tgrapperon]

It should be relatively straightforward to write something that will work more or less the same. For example:

extension Publisher where Failure == any Error {
  public var valuesCompat: AsyncThrowingStream<Output, Failure> {
    AsyncThrowingStream { continuation in
      let cancellable = self.sink { completion in
        switch completion {
        case let .failure(error):
          continuation.finish(throwing: error)
        case .finished:
          continuation.finish()
        }
      } receiveValue: { value in
        continuation.yield(value)
      }
      continuation.onTermination = { _ in cancellable.cancel() }
    }
  }
}

[mbrandonw]

@stephencelis's answer in that post should also help you:

return .publisher {
  executeAPublisherThatCanFailAndReturnsVoid()
    .receive(on: mainQueue)
    .map { .handleSuccessEffect }
    .catch { _ in .handleErrorEffect }
}

[WedgeSparda]

Hi @mbrandonw

Tried that approach, but I'm getting a compile error on the .catch { _ in .handleErrorEffect } line

Type 'Publisher' has no member 'handleErrorEffect'

[mbrandonw]

@WedgeSparda I guess you have to return a publisher from .catch, so it would be:

.catch { _ in Just(.handleErrorEffect) }

[WedgeSparda]

Ah, that's it. Silly me.

Thank you :)