How can you capture an imutable state within a .run Effect

[Dominic263]

Hi folks just a quick question ,
How can you capture and use an imutable value in an asynchrounous context using the EffectTask.run effect? I know how to do this using the .task effect

return .run { [state] in
// do something with state in this asynchronous context
}

but how can i do the same thing with .run .
Thanks for your help!

[mbrandonw]

Hi @Dominic263, capturing immutable state in Effect.run works the same as Effect.task. Does it not work for you? Can you share some code?

[Dominic263]

Hi Brandon,

I think I found a solution to the issue ; this seems to be working but I have a question (below)

return .run `{` [ids]  send in
                    
                    for id in ids {
                      await send(.updateAnnotations(id))
                    }
 }

where ids is an array of UUID's and updateAnnotations is a Parent action which takes a UUID as one of its argumemts.

This is how the updateAnnotations action then returns the effect defined beelow once it receives an id

        ```
return .task { [state] in
                return .annotation(id: id, action: .changeEnergyOptions(state.energy))
            }

It is caling a child action called changeEnergyOptions. 

Is there a better way to handle an action that you want to apply to every single element in an IdentifiedArray of a child state? I looked up the Todo's example but I didn't see an example of such a case. 

[mbrandonw]

I don't think it's necessary to send actions around like this. Effects are meant for interacting with the outside world and feeding data back into the system. Neither of your effects are doing that.

Is there a reason you can't simply iterate over the ids directly in the reducer (not the effect) and perform the logic on each element of the array?

We also have an article where we detail why it's not appropriate to use effects to send actions without interacting with the outside world.

[Dominic263]

Hi Brandon,

Thank you for this response. I have now started using shared functions for actions that need to be executed within my feature's reducer but now I have a slightly different issue. How do you drill down to a child action in the parent Reducer ?

say for instance you have a child reducer which is a leaf reducer that uses the reduce function like this

public func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
        switch action {
        case .endButtonTapped:
            state.currentTime = 0
            return cancelTimer()
            
        case .pause:
            return cancelTimer()
            
        case .tick:
            state.currentTime += 1.0
            if state.currentTime == state.sprintTime + 1  {
                state.currentTime = 0
                return cancelTimer()
            }
            state.displayFormattedTime = display(seconds: state.currentTime)
            return .none
            
        case .startButtonTapped:
            
            return .run {  send in
                for await _ in self.clock.timer(interval: .seconds(1)) {
                    await send(.tick)
                }
            }.cancellable(id: TimerID.self, cancelInFlight: true)
          
        }
    }

Now in the parent reducer suppose you have scope'd out the child reducer and set everything up well and you have an action which when called triggers one of the child actions to be executed as well

// This is part of the reducer within the switch action block
case .parentAction: 
//maybe do some logic that changes state of parent state 
// how do you trigger the child action here ??

Thanks for your help!

[mbrandonw]

Hi @Dominic263,

this can be handled in the same way, by using a little helper function, but with one additional step that must be taken.

First, extract out the action's mutation+effects to a helper. Since it needs to be accessible from the parent domain it can't be a method on the child reducer. It can either be a free function or even a mutating method on the state. I'll do the latter:

extension ChildFeature.State {
  mutating func doSomething() -> EffectTask<Action> {
    @Dependency(...) var ...
    // Make state mutations and return effects
  }

Then you call that from your child feature:

case .childButtonTapped:
  return state.doSomething()

And you can even call it from the parent feature, but you must .map on the effect in order to bundle the child action into the parent action:

case .parentButtonTapped:
  return state.child.doSomething()
    .map(Action.child)

That should make it possible to invoke the child's logic/behavior without sending synchronous actions around.

Now, that above is how I would personally do it because it gives you the most flexibility. For example, maybe in .childButtonTapped you want to do extra work outside of the doSomething that is specific to only when the child action is sent. You can easily do that:

case .childButtonTapped:
  // Additional logic here
  return state.doSomething()

But, there is another approach you can take that is less flexible, but also gets the job done. And that is you can simply invoke the child feature's reducer directly inside the parent:

case .parentButtonTapped:
  return Child().reduce(into: &state.child, action: .childButtonTapped)
    .map(Action.child)

That works just fine, and is in fact an adhoc version of what the Scope reducer does under the hood.

[Dominic263]

Hi Brandon. It works like a charm! Thanks for the help.