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 🙏

[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?