How to call Child's action directly?

[jerryga]

Reference: #1952 (comment)
In this discussion, In the mutating method, I know we can modify the data in the child.
But how can we call a child's action from its parent?

extension Child.State {
mutating func playCurrent() -> Effect<Child.Action> {
   self.index = self.index + 1
  return .run { send in
      await send(.play) //  **this code is not called. why?**
   }.cancellable(id: SubtitleCore.CancelID.play, cancelInFlight: false)
 }
}

[jerryga]

The log "print("Child action is called")" is not called, why?

struct Parent: Reducer{
    struct State{
        var child: Child.State
    }
    
    enum Action {
        case triggerChildAction
        case child(action: Child.Action)
    }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .triggerChildAction:
                // From Parent Reducer, call Child action by its playCurrent() function
                state.child.playCurrent()
                return .none
            case .child(action: let action):
                return .none
            }
        }
    }
}

extension Child.State {
  mutating func playCurrent() -> Effect<Child.Action> {
      
      return .run { send in
          await send(.play)
      }
      .cancellable(id: Child.CancelID.play, cancelInFlight: true)
  }
}

struct Child: Reducer{
    struct State{
        
    }

    enum Action {
        case play
    }
    private enum CancelID { case play }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .play:
                print("Child action is called")
                return .none
            }
        }
    }
}

[jerryga]

Hello, @mbrandonw , If Parent have a lot of children, how to do that?

struct Parent: Reducer{
    struct State: Identifiable{
        var children: IdentifiedArrayOf<Child.State> = []
        var id: Int
    }
    
    enum Action {
        case triggerChildAction
        case child(id: Parent.State.ID, action: Child.Action)

    }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .triggerChildAction:
                // From Parent Reducer, call Child action by its playCurrent() function
                return state.children.first!.playCurrent().map(Action.child) 

> The above line code： Error occurred: Cannot convert value of type 
'(Parent.State.ID, Child.Action) -> Parent.Action' (aka '(Int, Child.Action) -> Parent.Action') 
to expected argument type '(Child.Action) -> Parent.Action'

            case .child:
                return .none
            }
        }
        .forEach(\.children, action: /Action.child) {
            Child()
        }
    }
}

[mbrandonw]

How do you know which child you want to act upon? You only have an action that says triggerChildAction, but you have an entire identified array of children state. You need the ID of the child you want to operate on somehow.

[jerryga]

In the actual application, I know it. In this sample project, I just want the first child of the identified array to perform the playCurrent function.

[mbrandonw]

If you just want to affect the first, then you need to get the ID of the first element:

guard let firstID = state.children.first?.id
else { return .none }

return state.children[id: firstID]!.playCurrent().map(Action.child) 

I recommend reading the docs for IdentifiedArray to better understand how to use that type.

[jerryga]

Hello @mbrandonw, I have successfully passed events from parent to child. Here is my Code:
Thank you very much.
For those who need it:

import Foundation
import ComposableArchitecture

struct Parent: Reducer{
    struct State: Identifiable{
        var children: IdentifiedArrayOf<Child.State> = []
        var id: Int
    }
    
    enum Action {
        case triggerChildAction
        case child(id: Parent.State.ID, action: Child.Action)

    }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .triggerChildAction:
                guard let firstID = state.children.first?.id
                else { return .none }
                let childAction = state.children[id: firstID]!.playCurrent().map { Parent.Action.child(id: firstID, action: $0) }
                return childAction
            case .child:
                return .none
            }
        }
        .forEach(\.children, action: /Action.child) {
            Child()
        }
    }
}

extension Child.State {
  mutating func playCurrent() -> Effect<Child.Action> {
      
      return .run { send in
          await send(.play)
      }
      .cancellable(id: Child.CancelID.play, cancelInFlight: true)
  }
}

struct Child: Reducer{
    struct State: Identifiable{
        var id: Int

    }

    enum Action {
        case play
    }
    private enum CancelID { case play }
    
    var body: some Reducer<State, Action> {
        Reduce { state, action in
            switch action {
            case .play:
                print("Hello, Child action is called")
                return .none
            }
        }
    }
}