Observable Raw types in Presentation States in TCA – Can We Simplify with a Generic OptionalReducer?

[OguzYuuksel]

I'm exploring a design where certain features are optional, same as presentation states. For instance, in the code below, I have an optional state property along with a corresponding action wrapped in a presentation-specific type:

extension FooReducer {
    @ObservableState
    struct State {
        @Shared var nonOptionalValue: String
        // Imagine this is an optional feature that can be considered as presentation state.
        @Shared var optionalValue: String?
    }
}

extension FooReducer {
    @CasePathable
    enum Action: Sendable, Equatable {
        case setNonOptionalValue(String)
        case setOptionalValue(PresentationAction<String>)
    }
}

@Reducer
struct FooReducer {
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case let .setNonOptionalValue(value):
                state.$nonOptionalValue.withLock { $0 = value }
                return .none
            default:
                return .none
            }
        }
        .ifLet(\.optionalValue, action: \.setOptionalValue) {
            Reduce { state, action in
                 //   proper DSL to handle logic
                return .none
            }
        }
    }
}

struct FooView: View {
    public typealias Reducer = FooReducer
    @SwiftUI.Bindable private var store: StoreOf<Reducer>

    public init(store: StoreOf<Reducer>) {
        self.store = store
    }

    var body: some View {
        EmptyView()

//        if let $childStoreBinding: Binding<Store<String, String>> = Binding($store.scope(state: \.optionalValue, action: \.setOptionalValue)) {
//           // We cannot use $childStore.state.sending(\.action)
//           // Because requirement is _StoreBindable_SwiftUI<State: ObservableState, Action, Value>
//           // Binding is not Bindable and String is not ObservableState
//           // To workaround that we can create a sub reducer but imagine if you have a lot of these optional logics in your codebase
//           // There will be thousands of lines code just to wrap these sub states, we need to provide some generic OptionalReducer<V> or sth.
//        }
    }
}

The Issue

The challenge arises when trying to bind an optional substate via a scoped store. The binding requirements (_StoreBindable_SwiftUI<State: ObservableState, Action, Value>) aren’t met because:

• The Binding type doesn't have sending method and we can't scope to Bindable protocol.
• The String isn’t treated as an ObservableState.

This forces us into writing extra boilerplate—wrapping each optional state in a sub-reducer—to get the bindings to work correctly. In a codebase with many such optional features, this can quickly lead to an overwhelming amount of repetitive code.

Proposed Discussion Points

1. Generic OptionalReducer:
   Would it be feasible to introduce a generic solution (e.g., OptionalReducer<V>) within TCA that could automatically handle the nuances of optional presentation states? This could help reduce boilerplate significantly.

2. Alternative Patterns:
   Are there any existing patterns or best practices in TCA that can elegantly manage optional state bindings without resorting to manually creating numerous sub-reducers?

I'm eager to hear insights from others who may have encountered similar challenges or have suggestions on how to approach this issue more elegantly within the TCA. Any feedback, alternative solutions, or discussions on potential impacts would be greatly appreciated!