TCA State is struct, but struct cannot have a stored property that recursively contains it, How TCA write code to design linked struct state

[ACFancy]

QA

• TCA State is struct, but struct cannot have a stored property that recursively contains it
• So State properties can't recursively like

  struct AState : Equalable {
   var bState: BState?
  }
  struct BState: Equalable {
   var cState: CState?
  }
  struct CState: Equalable {
     var aState: AState?  // tips struct cannot have a stored property that recursively contains it
    var aStates: [AState] ? // this is allowed
   } 

• so how tca write code to design that case? HELP!!!!!

[stephencelis]

Swift's indirect keyword allows for value types to be recursive and moves a type's storage onto the heap. It's an enum feature that can be applied to the whole enum or a specific case, so you could kinda twist your data model from a struct into an enum with a single case that tuples all your struct fields, or you could use a property wrapper:

https://forums.swift.org/t/using-indirect-modifier-for-struct-properties/37600/14

[ACFancy]

• @Indirect fixed that compiling error,
  But there were some runtime error about reducer, tips. unsafeMutableAddressor when running app

let reducerA = .combine(reducerB.pullback.optional().xxx)  // tips:  unsafeMutableAddressor when running app
let reducerB = .combine(reducerC.pullback.optional().xxx)
let reducerC = .combine(reducerA.pullback.optional().xxx)

• @stephencelis , Is there a way to avoid that running time crash ?

[stephencelis]

@ACFancy You have some static recursion here (reducerA is defined using reducerB, which is defined using reducerC, which is defined using reducerA all over again), so you need to introduce some laziness here. There's an example for recursion in the repo, though it's admittedly complex: https://github.com/pointfreeco/swift-composable-architecture/blob/c0f266b79ad3354bb24c6ea3b778d57138a34bec/Examples/CaseStudies/SwiftUICaseStudies/04-HigherOrderReducers-Recursion.swift

If you're willing to use the Protocol Beta, recursion is much easier to define, as the "body" of the reducer is lazy by definition, and can refer to other static types:

struct ReducerA: ReducerProtocol {
  struct State { … }
  enum Action { … }

  var body: some ReducerProtocol<State, Action> {
    Scope(state: \.b, action: /Action.b) {
      ReducerB()
    }
  }
}

struct ReducerB: ReducerProtocol {
  struct State { … }
  enum Action { … }

  var body: some ReducerProtocol<State, Action> {
    Scope(state: \.c, action: /Action.c) {
      ReducerC()
    }
  }
}

struct ReducerC: ReducerProtocol {
  struct State { … }
  enum Action { … }

  var body: some ReducerProtocol<State, Action> {
    Scope(state: \.a, action: /Action.a) {
      ReducerA()
    }
  }
}

[ACFancy]

@stephencelis thanks for your reply.

• Recursion Sample, the sample isn't suitable for my case, it's recursion case for A has Array[A] properties,
  I had tried, but B Reducer action isn't called, I did'n know why

extension Reducer {
  static func recurse(
    _ reducer: @escaping (Self, inout State, Action, Environment) -> Effect<Action, Never>
  ) -> Self {

    var `self`: Self!
    self = Self { state, action, environment in
      reducer(self, &state, action, environment)
    }
    return self
  }
}

 let reducerA = Reducer<AState, AAction, AEnvironment>.recurse({ `self`, state, action, environment in
            switch action {
            case .onBClick:
                state.bState = .init()
                state.bVisible = true
                return  reducerB.optional().pullback(state: \.bState, action: /AAction.B) { _ in
                        .init()
                }
                .run(&state, action, environment)
            case .setNaivgationVisible(let visible):
                state.bVisible = visible
            default: break
            }
            return .none
    }).binding()

let reducerB: Reducer<BState, BAction, BEnvironment> = {
        return .combine(
            Reducer<BState, BAction, BEnvironment>.recurse({ `self`, state, action, environment in
        switch action {
        case .onCClick:
            state.cState = .init()
            state.cVisible = true
        case .setNaivgationVisible(let visible):
            state.cVisible = visible
        default: break
        }
        return .none
    }).binding(),
           reducerC.optional().pullback(state: \.cState, action: /BAction.C, environment: { _ in
                   .init()
           })
        )
    }()

• Protocol beta I will try after it is stable

[stephencelis]

@ACFancy The recurse helper should work just as well for nested optional state as it does for the array in our example. I believe you need to fully recurse from reducerA all the way to the next reducerA, though. It's definitely a bit of a pain, so we'd recommend using the protocol version, instead.

Protocol beta I will try after it is stable

We consider protocol-beta to be quite stable, just not quite as stable as a release branch. It's a beta mainly so we can gather feedback from folks like you 😄 We may make some API changes before merging, but will try to be forthcoming about anything like that in documented pull requests. In general, though, we don't anticipate anything major. If you do hit any issues, though, you can bring them up in a discussion!

[ACFancy]

@stephencelis thanks for your reply and suggest 🙂

• I had tried protocol-beta, the recurse problem was solved. 👍
• But I have some questions
  • Is there a migrate doc about how binging(), combine() to BindingReducer() and CombineReducers(reducers) ?
  • Is there doc about new ViewStoreOf init function migrate from withViewStore(store, observer: xxx)

      let viewStore: ViewStoreOf<Reducer> = ViewStore(store)
      // is same to the below code?
      withViewStore(store, observe: { $0 }) { viewStore in xxx}

  • Is the two way write code style same result? what's the best way about TCA ReducerProtocol code style?

       var body: some ReducerProtocol<State, Action>  {
            BindingReducer()
            CombineReducers(
                reducer()....  
           ) 
       }
       var body: some ReducerProtocol<State, Action>  {
            CombineReducers(
               BindingReducer()
                reducer()....  
           ) 
       }

[gandhimena]

you can find an example here @ACFancy:
https://github.com/pointfreeco/swift-composable-architecture/blob/main/Examples/CaseStudies/SwiftUICaseStudies/00-Core.swift

[hayek]

I created a box solution tailored for TCA for those who may be interested:
https://gist.github.com/hayek/46b32df656edca40dcbd955572b941eb

any feedback is welcomed.