Questions about Nested State usage

[mamboer]

The Scene

View A contains View B, when View A's reset action is being triggered, the reset action of View B should be triggered also.

The Reducer looks like

ViewBFeat.swift

@Reducer
struct ViewBFeat {
  @ObservableState
  struct State: Equatable {
    var y: Float = 0
  }
  
  enum Action {
    case reset
  }
  
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .reset:
        state.y = 0
        return .none
      }
  }
}

ViewAFeat.swift

@Reducer
struct ViewAFeat {
  @ObservableState
  struct State: Equatable {
    var viewB: ViewBFeat.State = .init()
    var x: Float = 0
  }
  
  enum Action {
    case viewB(ViewBFeat.Action)
    case reset
  }
  
  var body: some ReducerOf<Self> {
    Scope(state: \.viewB, action: \.viewB) {
      ViewBFeat()
    }
    Reduce { state, action in
      switch action {
      case .reset:
        state.x = 0
        // Can we trigger ViewBFeat's reset action here? how?
        return .none
      default:
        return .none
      }
  }
}

My question is

Can we trigger ViewBFeat's reset action inside ViewAFeat? how?

Wish you a good day!

[mamboer]

Currently, I am proceeding in this manner, which seems somewhat inelegant.

store.send(.reset)
store.scope(state: \.viewB, action: \.viewB).send(.reset)

[kevinanderson7]

@mamboer I think your question might be similar to this: #1952

[mamboer]

@kevinanderson7 Thanks for your tips.
According to the answer from #1952, it seems that we can simply update the Child feature's state directly in the parent's reducer, right?

@Reducer
struct ViewAFeat {
  @ObservableState
  struct State: Equatable {
    var viewB: ViewBFeat.State = .init()
    var x: Float = 0
  }
  
  enum Action {
    case viewB(ViewBFeat.Action)
    case reset
  }
  
  var body: some ReducerOf<Self> {
    Scope(state: \.viewB, action: \.viewB) {
      ViewBFeat()
    }
    Reduce { state, action in
      switch action {
      case .reset:
        state.x = 0
        // update ViewBFeat's state directly  if there's no other complex logic
        state.viewB.y = 0
        return .none
      default:
        return .none
      }
  }
}

[kevinanderson7]

That's one way to go about it. Or you could declare a mutating func as part of ViewBFeat.State and then call it from ViewAFeat. Something like this:

@Reducer
struct ViewAFeat {
  @ObservableState
  struct State: Equatable {
    var viewB: ViewBFeat.State = .init()
    var x: Float = 0
  }
  
  enum Action {
    case viewB(ViewBFeat.Action)
    case reset
  }
  
  var body: some ReducerOf<Self> {
    Scope(state: \.viewB, action: \.viewB) {
      ViewBFeat()
    }
    Reduce { state, action in
      switch action {
      case .reset:
        state.x = 0
        // update ViewBFeat's state directly or with mutating func
        // state.viewB.y = 0
        state.viewB.reset()
        return .none
      default:
        return .none
      }
  }
}

@Reducer
struct ViewBFeat {
  @ObservableState
  struct State: Equatable {
    var y: Float = 0

    mutating func reset() {
      self.y = 0
    }
  }
  
  enum Action {
    case reset
  }
  
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .reset:
        state.reset()
        return .none
      }
  }
}

Then you can just reuse that reset() in both the child and the parent.

[mamboer]

Got it, thank you!

[kevinanderson7]

You're welcome!

[Narsail]

While this seems useful, it does leak some of the states functionality from ViewB into ViewA which creates coupling.

One way I saw before was to use the Child Reducer directly. That's how I implement child reducer manipulation without running an unnecessary effect and without the parent needing knowledge about the internal of the child state.

This is especially helpful to me when you child reducer is getting more and more complex, i.e. .reset could have a chain reaction of events within the child reducer that couldn't be easily capture by a function.

@Reducer
struct ViewAFeat {
  @ObservableState
  struct State: Equatable {
    var viewB: ViewBFeat.State = .init()
    var x: Float = 0
  }
  
  enum Action {
    case viewB(ViewBFeat.Action)
    case reset
  }
  
  var body: some ReducerOf<Self> {
    Scope(state: \.viewB, action: \.viewB) {
      ViewBFeat()
    }
    Reduce { state, action in
      switch action {
      case .reset:
        state.x = 0
        // update ViewBFeat's state directly  if there's no other complex logic
        let effect = ViewBFeat()
          .reduce(into: &state.viewB, action: .reset)
          .map { .viewB($0) }
    
        return effect
      default:
        return .none
      }
  }
}