fireAndCatch - For ignoring publisher Output, but catching the Failure

[rhysm94]

I've been working on a project where multiple dependencies use Void Publishers to indicate when something has completed - i.e. with our database dependency (GRDB), when we persist something in the database, the writePublisher's success type is Void. Similarly, with some of our API requests, we don't have any body in the response to decode, just we just care that has succeeded. However, in these instances, we do care if they have failed.

One of the problems I was having with this is that turning an AnyPublisher<Void, Failure> into something that can easily be consumed by a reducer can be a bit verbose. My naïve approach was something along these lines:

enum Action {
  case performAction
  case result(Result<Never, Failure>)
}

// Inside reducer
case .performAction:
  return publisher
    .flatMap { _ in Empty<Never, Failure>() }
    .catchToEffect()
    .map(Action.result)

case let .result(.failure(failure)):
  // do something with failure
  return .none

This approach works, but is verbose to add manually for every Void Publisher/Effect.
It also adds a requirement to use Result<Never, Failure> in the action which handles the response, due to the need to map from the catchToEffect. Thankfully, you don't have to handle the .success case at all, as it cannot be created, but you still have to add the

I'm fully aware I could just be missing something, and there's already a way to do this in TCA - if there is, please let me know, I'd be very grateful! However, since I can't currently find anything, after a discussion on the Swift Forums, I've implemented something very similar to fireAndForget that I call fireAndCatch:

extension Publisher {
  public func fireAndCatch() -> Effect<Failure, Never> {
    flatMap { _ in
      Empty<Failure, Failure>()
    }
    .catch(Just.init)
    .eraseToEffect()
  }
}

This allows you to ignore any output from a Publisher other than that it has succeeded, and pushing the Failure into the Output case if a Failure does occur. This changes the above example to this:

enum Action {
  case performAction
  case failure(Failure)
}

// Inside reducer
case .performAction:
  return publisher
    .fireAndCatch()
    .map(Action.failure)

case let .failure(failure):
  // do something with failure
  return .none

It's a small change on the whole, but I feel it makes dealing with Publishers which don't feed data back into the system nicer to work with. There's no handling an unnecessary Result type, there's no explicit flatMap of the Publisher to Empty, as it's all handled for you.

I was originally going to scope this to an extension only when the Output == Void but I noticed that the fireAndForget has become more permissive recently, allowing allowing it to be called on any Publisher, regardless of Output or Failure type, so I brought this idea into fireAndCatch too.

Is this a problem anyone else has encountered, and solved in other ways?

[mbrandonw]

Hi @rhysm94, from my perspective what you've done seems completely fine and I like the .fireAndCatch naming too. I don't know of anything in TCA that would make what you are doing more succinct or more correct.

[rhysm94]

Awesome! Is this something that could potentially be included in TCA? I have got a PR (with testing) in a fork, but I didn't want to make a PR without checking if this is something you'd want first 😅

[jasdev]

(Digging fireAndCatch! I don’t have a strong take on the implementation, but might be slightly nicer to avoid the flatMap-Empty dance with ignoreOutput.)

extension Effect {
  public func fireAndCatch() -> Effect<Failure, Never> {
    ignoreOutput()
      .map { _ -> Failure in }
      .catch(Just.init)
      .eraseToEffect()
  }
}

[rhysm94]

Ah, I like that! Even clearer what's happening 😄

[siejkowski]

@mbrandonw was mentioning somewhere that they plan to create a TCA-community project, maybe that would be a good place for such useful extensions? It would allow adding more TCA ergonomics and some larger patterns without significantly expanding the TCA API, which I know that you want to keep small :)