Deriving shared state of collections other than IdentifiedArray

[kamcma]

I've been wanting to experiment with deriving shared state of collections beyond IdentifiedArray (trees, etc).

I see swift-sharing provides this functionality to IdentifiedArray by custom initializers on RangeReplaceableCollection that take a _(Mutable)IdentifiedCollection.

I wondered if it would be possible to implement similar initializers that take either Collections of Identifiable Elements, or a Collection and a KeyPath<Element, ID>, like the ForEach initializers from SwiftUI.

I sketched the following:

import Algorithms
import OrderedCollections
import Sharing

extension RangeReplaceableCollection {
  public init<Value: MutableCollection>(
    _ shared: Shared<Value>
  ) where Element == Shared<Value.Element>, Value.Element: Identifiable, Value.Index: Hashable {
    self.init()
    let value = shared.wrappedValue
    let indexedIdentifiers = OrderedDictionary(
      uniqueKeysWithValues: value.indexed().map { ($1.id, $0) }
    )
    self.reserveCapacity(value.count)
    for id in indexedIdentifiers.keys {
      self.append(shared[indexedIdentifiers[id]!])
    }
  }

  public init<Value: MutableCollection, ID: Hashable>(
    _ shared: Shared<Value>,
    id: KeyPath<Value.Element, ID>
  ) where Element == Shared<Value.Element>, Value.Index: Hashable {
    self.init()
    let value = shared.wrappedValue
    let indexedIdentifiers = OrderedDictionary(
      uniqueKeysWithValues: value.indexed().map { ($1[keyPath: id], $0) }
    )
    self.reserveCapacity(value.count)
    for id in indexedIdentifiers.keys {
      self.append(shared[indexedIdentifiers[id]!])
    }
  }
}

Do these implementations seem valid?

I think (?) the dictionary mapping IDs to Indexes is kind of a lightweight version of what SwiftUI's ForEach does when it creates this IndexedIdentifierCollection internally. Alas, that type has no public initializers, and here we wouldn't want to depend on SwiftUI anyway. (Though that type is why I named the dictionary value such as I did, but I'm not wedded to it if there's something more sensible. Should it actually be ... identifiedIndexers? 🤔 Not sure.)

Slightly less efficient than the _(Mutable)IdentifiedCollection initializers, which have the IDs at the ready and are subscriptable by them, but maybe an acceptable trade-off for allowing less specialized collections?

(And of course you could create a pair of SharedReader counterparts. And you could drop the swift-algorithms dependency and just zip the IDs and Indexes.)

Any thoughts? Would these initializers be generally useful? Are there other ways to go about this than RangeReplaceableCollection initializers?

[stephencelis]

At a glance this looks sound to me, but I'd be cautious with exotic uses of bindings and ForEach in SwiftUI. Once you hand a binding or data off to ForEach then SwiftUI can do whatever it wants to them outside the view body lifecycle, like invoking invalid subscript indices and crashing the app. While I think these issues are avoided here, it's still something to be mindful of.

And so the main other concern you bring up is performance, where there is an extra data structure created, iterated over, and destroyed.

Caveats aside, if you explore this further and discover anything interesting, please report back :)