Better way to change state when child state changes

[kakaopayios]

I want to change my enum state when child state changed.
I can accomplish it by receiving and processing a child's action.
But I'm wondering if there's a better way.
Is it possible to observe the child's status value and automatically change my status?

here is my sample code.

import ComposableArchitecture

struct Child: Reducer {
    struct State: Equatable {
        var currentSelection: Selection = .childSelection1
        
        enum Selection: Equatable {
            case childSelection1
            case childSelection2
        }
    }
    // ...
}

struct Parent: Reducer {
    struct State: Equatable {
        var child: Child.State
        // I want to change content when child.state changes
        var content: Content
        /** this doesn't compiles
         var content: Content {
            switch child.currentSelection {
            case .childSelection1: return .contentOne(.init())
            case .childSelection2: return .contentTwo(.init())
            }
         }
         */
        
        enum Content: Equatable {
            case contentOne(ContentOne.State)
            case contentTwo(ContentTwo.State)
        }
    }
    // ...
}

[tgrapperon]

Hey @kakaopayios. The code you're showing should compile, but I guess that you're trying to scope onto the Content domain. In this case, the library requires a writable KeyPath to write the reduced state back. The computed property you defined for Content only had a getter, so that may explain why it failed to build if you're scoping somewhere through .content.

You can thus probably try to implement it as:

private var _contentOne: ContentOne.State = .init()
private var _contentTwo: ContentTwo.State = .init()
var content: Content {
  get {
    switch child.currentSelection {
    case .childSelection1: 
      return .contentOne(_contentOne)
    case .childSelection2: 
      return .contentTwo(_contentTwo)
    }
  }
  set {
    switch newValue {
    case let .contentOne(newContent):
      self._contentOne = newContent
	case let .contentTwo(newContent):
      self._contentTwo = newContent
    }
  }
}

This can seems a little odd to have both content type alive at the same time. If you want to avoid this configuration, you can use this alternative way:

var _content: Content? // Or a non-optional placeholder.
var content: Content {
  get {
    switch child.currentSelection {
    case .childSelection1:
	  if case .contentOne = _content {
        return _content!
      }
      _content = .contentOne(.init())
      return _content!
    case .childSelection2: 
	  if case .contentTwo = _content {
        return _content!
      }
      _content = .contentTwo(.init())
      return _content!
    }
  }
  set {
	_content = newValue
  }
}

Both styles behave differently when you switch the currentSelection. The first one saves the state of the non-selected feature, whereas the second approach regenerates a new initial State when you change the currentSelection.

Alternatively, you can maybe also remodel your domain so the selected state lives in the selection enum:

enum Selection {
  case childSelection1(ContentOne.State)
  case childSelection2(ContentTwo.State)
}

But this is maybe not possible given the way your model is organized. It also behaves like the second solution, which may be something you don't want.

Writing this response reminds me a similar one that I wrote in these discussions a few months ago. I'll try to find it back. Please let me know if this doesn't help.