Key path value type with IdentifiableArrayOf<>

[dmeehan1968]

Xcode 13.1, Monterey, project targetting iOS 15, Swift 5

I'm new to TCA, fairly new to SwiftUI, and exploring the example projects and putting my own spin on them to explore TCA. I'm currently working through the Todos example, and wondered about why the AppState and AppView's View State seem to be conflated. That lead me to building up the example from scratch, which gave me a state structure with only one member - the list of items.

struct ItemList: Equatable {
    var items: IdentifiedArrayOf<Item> = []
}

It occured to me that I could create just a typealias to the underlying list, so used:

typealias ItemList = IdentifiedArrayOf<Item>

which allows me to be more consise in my reducer:

    Reducer { itemList, action, _ in
        switch action {
        case let .append(item):
            itemList.append(item)   // instead of itemList.items.append(item)
            return .none
        case .item:
            return .none
        }
    }

The problem is a compile error, when trying to use a keypath to self (not supported in Swift 4). In my ItemListView, I have:

struct ItemListView: View {
    var store: ItemListStore

    var body: some View {
        WithViewStore(self.store) { viewStore in
            List {
                ForEachStore(
                    self.store.scope(state: \ItemList.self, action: ItemListAction.item(id:action:)), // NB compile error
                    content: ItemRow.init(store:)
                )
            }
        }
    }
}

which produces a compile error of:

Key path value type 'ItemList' (aka 'IdentifiedArray<UUID, Item>') cannot be converted to contextual type 'IdentifiedArray<Item.ID, Item>' (aka 'IdentifiedArray<UUID, Item>')

Item is defined as:

struct Item: Identifiable, Equatable {
    var id = UUID()
    var title: String
    var isComplete: Bool = false
}

So, Item.ID is of type UUID, so it appears that something is confusing the definition of Item.ID. I tried changing the typealias to:

typealias ItemList = IdentifiableArray<UUID,Item>

which gives the same compiler error, and changing it to:

typealias ItemList = IdentifiableArray<Item.ID, Item>

Also produces the same error.

Being more explicit/direct with the typing of the keypath seems to be even more contradictory:

self.store.scope(state: \IdentifiedArray<Item.ID,Item>.self, action: ItemListAction.item(id:action:)),

gives:

Key path value type 'IdentifiedArray<Item.ID, Item>' (aka 'IdentifiedArray<UUID, Item>') cannot be converted to contextual type 'IdentifiedArray<Item.ID, Item>' (aka 'IdentifiedArray<UUID, Item>')

The motivation here was to remove the redundant level of enclosure (items property in ItemList) as it seems to compile ok elsewhere by using .self as the keypath.

This seems like something that 'should' work, and in fact I did find a workaround, which seems a bit esoteric, but gives this:

protocol KeyPathSelfProtocol {}
extension KeyPathSelfProtocol {
  var keyPathSelf: Self {
    get { return self }
    set { self = newValue }
  }
}

extension IdentifiedArrayOf: KeyPathSelfProtocol {}

typealias ItemList = IdentifiedArrayOf<Item>

struct ItemListView: View {
    var store: ItemListStore

    var body: some View {
        WithViewStore(self.store) { viewStore in
            List {
                ForEachStore(
                    self.store.scope(state: \.keyPathSelf, action: ItemListAction.item(id:action:)),
                    content: ItemRow.init(store:)
                )
            }
        }
    }
}

[stephencelis]

@dmeehan1968 Store.scope actually takes a transform function and not a key path. When you see the key path it's because key path literals can often be used as a shorthand for a function.

The following, for example, are equivalent:

users.map { $0.name }
users.map(\.name)

I think the problem you're encountering is this bug (or rather, a bug related to this bug):

https://bugs.swift.org/browse/SR-12422

Hopefully it will be fixed some day, but in the meantime, you should be able to get by with an identity closure instead:

self.store.scope(state: { $0 }, action: ItemListAction.item(id:action:)),

[dmeehan1968]

So blissfully simple when you know how! Thanks very much.