struct State with enum Properties

[tgt]

I have a few questions about how to use TCA's new support for enum state when that state is a property of struct state.

For example,

enum Feature: Equatable {
    case first(FirstFeature)
    case second(SecondFeature)
}

struct Root: Equatable {
    var feature: Feature = .first(FirstFeature())
    
    // Other properties
}

enum RootAction: Equatable {
    ...
	
    case firstFeature(action: FirstFeatureAction)
    case secondFeature(action: SecondFeatureAction)
}

struct Environment { ... }

struct FirstFeature: Equatable { ... }
enum FirstFeatureAction: Equatable { ... }

struct SecondFeature: Equatable { ... }
enum SecondFeatureAction: Equatable { ... }

let firstFeatureReducer = Reducer<FirstFeature, FirstFeatureAction, Environment> { ... }
let secondFeatureReducer = Reducer<FirstFeature, FirstFeatureAction, Environment> { ... }

let rootReducer = Reducer<Root, RootAction, Environment>.combine(
    firstFeatureReducer.pullback(
        state: ???,
        action: /Root.firstFeature,
        environment: { $0 }
    ),

    secondFeatureReducer.pullback(
        state: ???,
        action: /Root.secondFeature,
        environment: { $0 }
    ),

    Reducer { ... }
)

I asked on Twitter and your suggestion was to use two pullbacks, which I believe means I should do the following:

firstFeatureReducer
    .pullback(
        state: /Feature.first,
        action: /RootAction.firstFeature,
        environment: { $0 }
    )
    .pullback(
        state: \.feature,
        action: /.`self`,
        environment: { $0 }
    )

This seems to accomplish what I want, so thank you.

1. Is this how you meant your suggestion to be implemented?

2. I'm now wondering how to use the onChange(of:) helper from isowords with this.

   Previously, I was using two optionals, so I could use

   .onChange(of: \.firstFeature?.property) { ... }

   But now that I'm using an enum I'm unsure of the best way to access properties contained in a case of the enum. Is this currently possible?

3. Is there a recommended way to cancel outstanding effects on one of the child reducers when the enum state changes? I can't dispatch an Effect to cancel them when changing the state since it won't be able to receive the action. For example,

   enum FirstFeatureAction: Equatable {
       case initialise
       case terminate
   }

   If initialise returns an Effect that needs cancelling in terminate, then when working with two optional states I could leave in place the state for the feature with Effects in need of cancellation and nil it in .firstFeature(.terminate) in the parent. I've not given it much thought yet, but currently just set a nextFeature and assign it to feature in .firstFeature(.terminate). That works, but complicates sending Effects that require the new state and I feel there should be a nicer way to handle it. (Previously, I could return actions for the new state and terminate for the old state at the same time.)

Please let me know if you'd like anything clarifying.

Thank you

[mbrandonw]

Is this how you meant your suggestion to be implemented?

Yeah this is exactly right. In a future release of TCA and swift-case-paths you will be able to collapse that into a single pullback by appending a case path to a key path.

I'm now wondering how to use the onChange(of:) helper from isowords with this.

Ah yes, one option is to open a closure to do the extraction of the case:

.onChange(of: { (/Feature.first).extract(from: $0.feature) }) { ... }

That's a bit intense, but it should work. Alternatively you could define a getter computed property var first: FirstFeature? on Feature to do the extraction.

Is there a recommended way to cancel outstanding effects on one of the child reducers when the enum state changes?

We don't have much information out there about this yet unfortunately. We will have more to say about it soon.

[tgt]

Ah, of course, thanks. That works, but I've gone with the computed property.

Looking forward to more about your plans for Effects