How to send an action with a closure as a parameter

[stevebegin]

In order to start implementing TCA in our large code base, I would like to do something like this:

func doThis(callback: @escaping () -> Void) {
    viewStore.send(.someAction(callback))
}

But unfortunately, having an action with a callback as a parameter makes the Action enum unable to conform to Equatable.

[boudavid]

Can you share some code to show why you need to do this ? Maybe there's an alternative solution.

[stevebegin]

Thanks for the reply, I have updated my question with more code.

[rhysm94]

It all depends what you're doing inside the callback, really.

If you're using it to update something in your view, you could change that property on whatever State this reducer is operating on, and then subscribe to the publisher for that state, updating your view as required?

If you're doing some asynchronous work, then you could instead drive that via an Effect.

Ultimately, the solution depends on what you're trying to achieve. Could you share your ideas, and perhaps some more code, to work out what the correct way to do it in TCA is?

[stevebegin]

Thanks for the reply, I have updated my question with more code.

[stevebegin]

Here's what we are trying to accomplish. We have a class (PowerMeter) that is used elsewhere in our program. This class needs to expose a programatic API with a way to get feedback since the task may fail. Currently we use a closure, but something else could deliver the Result.

Otherwise, the PowerMeter also has an associated view that uses the Store and the change in wavelength is handled by the store through and action.

final class PowerMeter: PhysicalDeviceWrapper {
    
    private var store: Store<PowerMeterState, PowerMeterAction>
    private var viewStore: ViewStore<PowerMeterState, PowerMeterAction>
    
    init() {
        self.store = Store(
            initialState: PowerMeterState(),
            reducer: powerMeterReducer,
            environment: PowerMeterEnvironment()
        )
        self.viewStore = ViewStore(store)
    }

    func set(wavelength: Double, completion: @escaping (Result<Response, Never>) -> Void) {
        /// What to do with the closure? 
        viewStore.send(.userSetCorrectionWavelength(wavelength))
    }
}

[rhysm94]

OK, is the PowerMeter something you could store in the Environment instead?
This would allow you to structure your code more like this:

struct PowerMeterEnvironment {
  var powerMeter: PowerMeter
}

enum PowerMeterAction: Equatable {
  case setWavelength(Double)
  case setWavelengthResult(Result<Response, Never>)
}

let powerMeterReducer = Reducer<PowerMeterState, PowerMeterAction, PowerMeterEnvironment> { state, action, environment in
  switch action {
    case let .setWavelength(wavelength):
      return .result { completion in
        environment.powerMeter.setWavelength(wavelength: wavelength, completion: completion)
      }
      .eraseToEffect()
      .map(PowerMeterAction.setWavelengthResult)

    case let .setWavelengthResult(result):
      // Do something with the result here
      return .none
}

[stevebegin]

I'm not sure how that helps since the PowerMeter methods will be called by another part of the code which is not tied into TCA.

class SomeOtherClass {
    var powerMeter: PowerMeter
    func doSomethingWithThePowerMeter() {
        powerMeter.set(wavelength: 200) { result in 
            /// Do something with the result in SomeOtherClass   
        }
    }

}

[rhysm94]

It really depends what you're trying to achieve, by adopting TCA in this bit of the application.

You could store a reference to a ViewStore<PowerMeterState, PowerMeterAction> in the SomeOtherClass.
Then you'd call viewStore.send(.setWavelength(200)) from the SomeOtherClass instance. Assuming that the .setWavelengthResult updates something on your PowerMeterState, you can then subscribe to the viewStore's publisher, to receive new values.

But all that's making an assumption as to how you're going to be using the PowerMeter within this bit of the application...

[stevebegin]

Thanks so much for your time.
We have thought of your last idea, but since there are many other actions that may affect the state at any time, we wouldn't have any guarantee that whatever comes from the viewStore.publisher is directly related to the action that was sent in SomeOtherClass()

[rhysm94]

Actually, you will have that guarantee, especially if you're only adopting TCA for this one particular section of code right now, as the only thing that can mutate the PowerMeterState is the PowerMeter reducer, and the only thing sending actions to your PowerMeter reducer is SomeOtherClass.

For the example's sake, setting the wavelength returns a Double value in the completion here:

struct PowerMeterState: Equatable {
  var currentWavelength: Double = 0
  var error: PowerMeter.Failure?
}

enum PowerMeterAction: Equatable {
  case setWavelength(Double)
  case setWavelengthResult(Result<Double, PowerMeter.Failure>)
  case dismissError
}

struct PowerMeterEnvironment {
  let powerMeter: PowerMeter
}

let powerMeterReducer = Reducer<PowerMeterState, PowerMeterAction, PowerMeterEnvironment> { state, action, env in
  switch action {
    case .setWavelength(let newWavelength):
      return .result { completion in // or .future if it's async
        env.powerMeter.setWavelength(wavelength: newWavelength, completion: completion)
      }

    case .setWavelengthResult(.success(let confirmedWavelength)):
      state.currentWavelength = confirmedWavelength
      return .none

    case .setWavelengthResult(.failure(let failure)):
      state.error = failure
      return .none

    case .dismissError:
      state.error = nil
      return .none
  }
}

Inside your SomeOtherClass, you can just create your Store<PowerMeterState, PowerMeterAction> and its ViewStore equivalent - assuming that for now, this is the only place you're using TCA for now. Later on, you can inject an instance of Store<PowerMeterState, PowerMeterAction> scoped from a parent store, if needed.

This way, you can be sure that the only changes being applied to the instance of PowerMeterState inside the powerMeterReducer are coming from actions send by your SomeOtherClass.

If I've misunderstood, and you want to receive all changes from a PowerMeter regardless of where sent the action, that's definitely still possible, but a bit more complex, so I'll avoid that for now haha

Hope this is useful in some way?

[mbrandonw]

Another option, in addition to everything discussed above, is to hold Result<Response, Never>? in state, set it when the action is sent, and then read from that state in the view as soon as the action is sent:

    func set(wavelength: Double, completion: @escaping (Result<Response, Never>) -> Void) {
        /// What to do with the closure? 
        viewStore.send(.userSetCorrectionWavelength(wavelength))

       // call the closure with data held in state after sending the action:
       if let response = viewStore.response {
         completion(viewStore.response)
       }
    }

This is pretty much the only way to handle APIs that have completion callbacks like this, unless you can refactor the API in something that is more friendly for the environment.

There are a few Apple APIs that follow this pattern. Things like background tasks and widgets have similar APIs.

[stevebegin]

Sounds like a good idea, but our .userSetCorrectionWavelength(wavelength) sends an asynchronous effect and the result that is interesting to us will come back after that effect. In this case, reading the viewStore.response right after the call would not be right.

[mbrandonw]

So it's still possible, just a little more gnarly! Now you have to hold the completion callback in your object and then subscribe to viewStore.response:

final class PowerMeter: PhysicalDeviceWrapper {
    
    private var store: Store<PowerMeterState, PowerMeterAction>
    private var viewStore: ViewStore<PowerMeterState, PowerMeterAction>
    private var completion: ((Result<Response, Never>) -> Void)?
    
    init() {
        self.store = Store(
            initialState: PowerMeterState(),
            reducer: powerMeterReducer,
            environment: PowerMeterEnvironment()
        )
        self.viewStore = ViewStore(store)

        self.viewStore.publisher.response
          .sink { [weak self] in 
            self?.completion($0)
            self?.completion = nil
          }
          // TODO: handle cancellable
    }

    func set(wavelength: Double, completion: @escaping (Result<Response, Never>) -> Void) {
        /// What to do with the closure? 
        viewStore.send(.userSetCorrectionWavelength(wavelength))
        self.completion = completion
    }
}

That'll get the job done.

[mbrandonw]

I suppose you could also move the self.viewStore.publisher.response.sink into the set(wavelength:) function too. Should be about the same and then you wouldn't have to hold onto completion in the object.