Can't use if let with ForEach

[kuglee]

Description

I'd like to use ForEach with an optional state. In this example I'm using a type RemoteResult. RemoteResult is annotated with @CasePathable and @dynamicMemberLookup.
The reducer seem to compile fine, but in the view I have the following error: Generic struct 'ForEach' requires that 'Store<IdentifiedArray<UUID, ChildFeature.State>, IdentifiedAction<UUID, ChildFeature.Action>>' conform to 'RandomAccessCollection'

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

In the AppView I expected that after if let scoping the store I can pass it to ForEach:

@Reducer public struct AppFeature: Sendable {
  public init() {}

  @ObservableState public struct State: Equatable {
    public var childStates: RemoteResult<IdentifiedArrayOf<ChildFeature.State>, AppError>

    public init(
      childStates: RemoteResult<IdentifiedArrayOf<ChildFeature.State>, AppError> = .initial
    ) { self.childStates = childStates }
  }

  public enum Action: Sendable { case childAction(IdentifiedActionOf<ChildFeature>) }

  public var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .childAction: return .none
      }
    }
    .ifLet(\.childStates.success, action: \.childAction) {
      EmptyReducer().forEach(\.self, action: \.self) { ChildFeature() }
    }
  }
}

public struct AppView: View {
  @Bindable var store: StoreOf<AppFeature>

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

  public var body: some View {
    if let store = self.store.scope(state: \.childStates.success, action: \.childAction) {
      ForEach(store) { ChildView(store: $0) } // expected this to work
    }
  }
}

Actual behavior

In the AppView I get the following error: Generic struct 'ForEach' requires that 'Store<IdentifiedArray<UUID, ChildFeature.State>, IdentifiedAction<UUID, ChildFeature.Action>>' conform to 'RandomAccessCollection'

@Reducer public struct AppFeature: Sendable {
  public init() {}

  @ObservableState public struct State: Equatable {
    public var childStates: RemoteResult<IdentifiedArrayOf<ChildFeature.State>, AppError>

    public init(
      childStates: RemoteResult<IdentifiedArrayOf<ChildFeature.State>, AppError> = .initial
    ) { self.childStates = childStates }
  }

  public enum Action: Sendable { case childAction(IdentifiedActionOf<ChildFeature>) }

  public var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .childAction: return .none
      }
    }
    .ifLet(\.childStates.success, action: \.childAction) {
      EmptyReducer().forEach(\.self, action: \.self) { ChildFeature() }
    }
  }
}

public struct AppView: View {
  @Bindable var store: StoreOf<AppFeature>

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

  public var body: some View {
    if let store = self.store.scope(state: \.childStates.success, action: \.childAction) {
      ForEach(store) { ChildView(store: $0) } // Generic struct 'ForEach' requires that 'Store<IdentifiedArray<UUID, ChildFeature.State>, IdentifiedAction<UUID, ChildFeature.Action>>' conform to 'RandomAccessCollection'
    }
  }
}

Steps to reproduce

Here's the demo project the example code is from: [TCACasePathIssue](https://github.com/kuglee/TCACasePathIssue)
Here's a simpler demo project with an if let ForEach that also has this issue: TCAForEachIssue

The Composable Architecture version information

1.14.0

Destination operating system

macOS

Xcode version information

Xcode 16.1 beta (16B5001e)

Swift Compiler version information

swift-driver version: 1.113 Apple Swift version 6.0 (swiftlang-6.0.0.7.6 clang-1600.0.24.1)
Target: arm64-apple-macosx14.0

[kamcma]

I suspect this is because, by nesting your identified array inside your own RemoteResult type that does not conform to ObservableState, you've broken the chain of observability and you're not using the overload of .scope() that you want. If you want to do this, you'll have to conform your RemoteResult type to ObservableState.

[kuglee]

Annotating RemoteResult with @ObservableState unfortunately doesn't fix the problem. The same error occurs.

[mbrandonw]

Hi @kuglee, the reason syntax like this works:

ForEach(store.scope(…)) { store in 
  …
}

…is because we have a special overload of scope that returns a collection. So, when you if let to unwrap a store.scope(…) you are just getting back a regular store, and that cannot be fed directly to ForEach.

Really this is a domain modeling problem. You shouldn't compose features together like this:

public var childStates: RemoteResult<IdentifiedArrayOf<ChildFeature.State>, AppError>

Not only is RemoteResult not a proper TCA feature, but either is IdentifiedArray. It should probably be better to model this like so:

public var result: RemoteResult<ChildrenFeature.State, AppError>

And then have a dedicated ChildrenFeature that holds onto the IdentifiedArrayOf<ChildFeature.State>. That would allow you to do something like this:

if let store = self.store.scope(state: \.result.success, action: \.result) {
  ForEach(store.scope(state: \.children, action: \.children)) { store in 
    …
  }
}

Since this is not an issue with the library I am going to convert it to a discussion. Please feel free to continue the conversation over there.

[kuglee]

Thank you for the explanation 🙏

[p4checo]

hi @mbrandonw,

In apps where we need to fetch/load data before showing it it's quite frequent/intuitive to model the state (or a part of it) as en enum such as the RemoteResult above, where the success/loaded state can be modeled as "just" an IdentifiedArrayOf<ChildFeature>, which perfectly represents the state.

I understand the domain modeling problem argument, and effectively modeling RemoteResult as a TCA Feature and wrapping the IdentifiedArray in the .success case inside its own TCA Feature "fixes" the issue, as in it allows us to make this work using the current APIs. However, I feel that it results in a bit of extra "boilerplate" when we could instead have an additional helper/overload to cover scenarios such as this one in a more ergonomic way. By scenarios such as this one I mean a TCA Feature where the State is an enum containing a case wrapping an IdentifiedArray and the Action enum contains a case with a matching IdentifiedAction.

IdentifiedArrays / IdentifiedActions are the de facto "TCA way" of modeling and composing arrays of child features into parent features, and we have dedicated APIs like Reducer.forEach and Store.scope (RandomAccessCollection) to work with them in an ergonomic way. Wouldn't it make sense to allow treating State enum cases containing an IdentifiedArray as an associated value as a "valid" child state composition pattern in the same way being a property of a State struct is? One could argue that it has some sort of symmetry, right? 🤓

The problem boils down to scoping out a RandomAccessCollection without this extra Reducer "hoop", so I thought about two possible approaches for this:

1. New Store.scope overload, essentially a mixture of Store.scope(enum) + Store.scope(RandomAccessCollection):

  @_disfavoredOverload
  public func scope<ElementID, ElementState, ElementAction>(
    state: KeyPath<State, IdentifiedArray<ElementID, ElementState>?>,
    action: CaseKeyPath<Action, IdentifiedAction<ElementID, ElementAction>>,
    fileID: StaticString = #fileID,
    filePath: StaticString = #filePath,
    line: UInt = #line,
    column: UInt = #column
  ) -> Optional<some RandomAccessCollection<Store<ElementState, ElementAction>>> {
    typealias _S = Store<IdentifiedArray<ElementID, ElementState>, IdentifiedAction<ElementID, ElementAction>>
    typealias _C = _StoreCollection<ElementID, ElementState, ElementAction>

    guard let store: _S = self.scope(state: state, action: action)
    else { return Optional<_C>.none }

    return _C(store)
  }

usage:

if let store = self.store.scope(state: \.result.success, action: \.result.success) {
  ForEach(store) { store in 
    …
  }
}

Observations:

• intuitive by using well known Store.scope signature
• perhaps too specialized, but can likely work for other scenarios due to the KeyPath and CaseKeyPath parameters
• will prevail over existing Store.scope for qualifying Stores, but it's probably safe to assume this is what users want when scoping to a store with this type signature

---

2. New Store.collection (or asCollection) helper that wraps any Store<IdentifiedArray<ElementID, ElementState>, IdentifiedAction<ElementID, ElementAction>> in a _StoreCollection (as a RemoteAccessCollection):

extension Store {
  public func collection<ElementID, ElementState, ElementAction>(
    fileID: StaticString = #fileID,
    filePath: StaticString = #filePath,
    line: UInt = #line,
    column: UInt = #column
  ) -> some RandomAccessCollection<Store<ElementState, ElementAction>>
  where State == IdentifiedArray<ElementID, ElementState>, 
  Action == IdentifiedAction<ElementID, ElementAction> {
    return _StoreCollection(self)
  }
}

usage:

if let store = self.store.scope(state: \.result.success, action: \.result.success) {
  ForEach(store.collection) { store in 
    …
  }
}

Observations:

• purely additive, as existing scoping APIs are preserved
• increases API surface with a new "operator", less intuitive
• simple implementation, as it's just a wrapper of qualifying Stores in a _StoreCollection

---

What are your thoughts on this? Thanks! 🙏🏼

[beribas]

Hi @mbrandonw,

thank you for the answer.
Does that mean that the approach with optional array in a state is considered as bad practice in general?

If I have a state with:
var items: IdentifiedArrayOf<ItemFeature.State>?

And an action:
case item(IdentifiedActionOf<ItemFeature>)

In the "viewstore era" I used:

IfLetStore(self.store.scope(state: \. items, action: \.item)) { itemListStore in
   ForEachStore(itemListStore) { itemStore in
      ItemView(store: itemStore)
   }
}

How would I migrate code like this into the Observable Architecture approach?
Can I feed an unwrapped store into ForEach to become a RandomAccessCollection of stores or do I need to extract this into a new Feature which would deal with nonoptional array of items?