Equatable for multiple presentation destinations

[leekurg]

Just learning TCA 1.8.2(and it's fabulous) with interactive tutorial, chapter Navigation
Multiple presentation destinations.

Tutorial says that if you want to model multiple presentation on one screen, you should use a single state property destination which controls every presentation. Tutorial suggests to use Destination struct, wrapped by @Reducer macro.

When I do so, compiler fails on ContactsFeature.State, because it is not conforms to Equatable, after adding this destination property. I assume this is because @Reducer macro does not add conformance to Equatable to underlying State.

I figured out that I can remove Equatable from State, and it will work, but then TestStore gives me a warning that State must be Equatable. I am confused.

So, is it right behaviour described by tutorial? What should I change to make it work?

Here is the code, I tried make it as short as possible:

@Reducer
struct ContactsFeature {
    @ObservableState
    struct State: Equatable {
        @Presents var destination: Destination.State?
    }

    enum Action {
        case destination(PresentationAction<Destination.Action>)
        case addButtonTapped
        case deleteButtonTapped(id: Contact.ID)

        enum Alert: Equatable {
            case confirmDeletion(id: Contact.ID)
        }
    }

    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .addButtonTapped:
                state.destination = .addContact(
                    AddContactFeature.State(
                        contact: Contact(id: UUID(), name: "")
                    )
                )
                return .none

            case .destination:
                return .none

            case let .deleteButtonTapped(id: id):
                state.destination = .alert(
                    AlertState {
                        TextState("Are you sure?")
                    } actions: {
                        ButtonState(role: .destructive, action: .confirmDeletion(id: id)) {
                            TextState("Delete")
                        }
                    }
                )
                return .none
            }
        }
        .ifLet(\.$destination, action: \.destination)
    }
}

extension ContactsFeature {
    @Reducer
    enum Destination: Equatable {
        case addContact(AddContactFeature)
        case alert(AlertState<ContactsFeature.Action.Alert>)
    }
}

struct Contact: Identifiable, Equatable {
    let id: UUID
    var name: String
}

[mbrandonw]

There may be a step missing from the tutorial that shows how to make those types Equatable. I'll take a look, but in the meantime you can find info on how to do that here:

https://pointfreeco.github.io/swift-composable-architecture/main/documentation/composablearchitecture/reducers#Synthesizing-protocol-conformances-on-State-and-Action

[leekurg]

Thanks for your answer, now it is working with:

@Reducer(state: .equatable)
enum Destination {
    ...
}