"Zooming in" on shared keys for smaller slices of observable state

[jessetipton]

In our codebase, we're finding more and more that we'd like to be able to "zoom in" on the value published by a given shared key in order to observe only a small piece of the value it shares.

As an example, imagine a struct representing a user's account that contains many, many properties:

struct Account {
    var email: String
    var phone: String
    // <imagine many more properties here>
}

And we'll assume some shared reader key exists that lets us observe the latest account value across the application.

To illustrate the potential value we see here, imagine a simple view that just wants to show the current account's email address in in a list:

struct AccountEmailView: View {
    @SharedReader(.account) var account

    var body: some View {
        List {
            LabeledContent("Email", value: account.email)
        }
    }
}

My understanding is that any new Account value yielded by the .account key will cause the view body to recompute. We'd also expect that if we were to move the @SharedReader(.account) var account property to an Observable object (e.g. a view model) or a TCA reducer's state, any change to the Account would result in the view body recomputing as well.

What seems reasonable to us is that there would be some way to observe just the data we need from the key, and reap whatever efficiency gains would come from that. Essentially, something like this:

struct AccountEmailView: View {
    @SharedReader(.account.map(\.email)) var email

    var body: some View {
        List {
            LabeledContent("Email", value: email)
        }
    }
}

We'd expect that the key returned by this imagined map(_:) function would only yield new values when the account's email property changes. Any new Account values that are updating other properties or provide the same email value would just be ignored.

Would anyone else find this a useful addition to the library? Are there costs or complexities we're overlooking in assuming this should be possible?