Nested optional shared state

[jiledaa]

Hi all, I'm kind of stuck on how to work with more complicated shared state(nested or optional). Lets say:

struct User {
    let service: Service?
}
struct Service {
    let array: [SomeModelWithID]
    let array2: [SomeOtherModelWithID]
}

@Reducer
public struct ParentFeature {
     @Reducer(state: .equatable, action: .equatable)
     public enum Path {
          case child(ChildFeature)
     }

    @ObservableState
    public struct State: Equatable {
        var path: StackState<ParentFeature.Path.State>

        @Shared var user: User?

        public init() {
            _user = Shared(nil)
        }
    }

    public enum Action: Equatable {
        case entries(IdentifiedActionOf<ChildFeature>)
    .......

then down in the reducer, I update user in some action and then have another action:

    case let .entries(.element(id: elementID, action: .delegate(.open))):
         state.path.append(
             .child(
                 ChildFeature.State(
                     sharedArray: // Here I need @Shared var that is User->Service->arrayElement->someArrayInsideElement
                 )
             )
          )
          return .none

Before I started to use shared states, I was able to do user?.service?.array.first(where: { $0.id == elementID })..., but now its a bit complicated...

[mbrandonw]

Hi @jiledaa, you can still do this but it takes more steps due to the fact that optional chaining in Swift does not preserve writability. So when you do:

$user.service?.array

…you get only a SharedReader<[SomeModelWithID]> since the key path \.service?.array is not writable. But you can do:

Binding($user.service)?.array

…to get a Shared<[SomeModelWithID]>?, i.e. an optional shared. Note that this Shared initializer transforms a Shared<A?> into Shared<A>?, and is similar to the corresponding Binding initializer.

Then you order to capture the .first(where: { … }) logic you should really be using an IdentifiedArray. If you were, then you could finish things off like this:

Binding(Binding($user.service)?.array[id: elementID])

This will give you a Shared<Model>?, which you can then unwrap and hand off to the child feature.

[jiledaa]

And this is a special binding constructor? I have imported TCA library in file but cannot use any Binding until I import SwiftUI, so I suppose Binding constructor you're mentioning is the native one. However, when I try to make Binding(state.$user.service), compiler does not infer the generic type, so I do Binding<User.Service>(state.$user.service), then I get the error: "Cannot convert value of type 'Shared<User.Service?>' to expected argument type 'Binding<User.Service?>'"

[mbrandonw]

Hi @jiledaa, I'm sorry there was a typo in those snippets. I meant Shared:

-Binding($user.service)?.array
+Shared($user.service)?.array

-Binding(Binding($user.service)?.array[id: elementID])
+Shared(Shared($user.service)?.array[id: elementID])

The Binding type has similar initializers, and Shared is kind of like that TCA version of Binding, and so that's why I mixed them up.

[jiledaa]

Hi again. Array is a property of the model, it is not identified array, because my models dont see on TCA library. I have identified array of objects, but not on this level that manages the path features. Identified array of objects made of this array is in the level below.

[mbrandonw]

Hi @jiledaa, you can depend on IdentifiedArray without depending on TCA. It's a separate library and useful even in vanilla SwiftUI.

And if you really are doing first { $0.id == elementID } in your code, then you basically are recreating what IdentifiedArray gives you for free, but in a very inefficient manner since you have to scan the entire array to find an element. So, I personally would recommend just making it an identified array.

However, if doing so right now is too big of a refactor, there is a shortcut you can take for right now, though I wouldn't keep it for a long period. You can define a subscript on Array<Model> that takes an ID and hides the first(where:) logic under the hood:

extension Array<Model> {
  subscript(id id: Model.ID) -> Model? {
    get {
      first { $0.id == id }
    }
    set {
      for index in indices {
        if self[index].id == model.id {
          self[index] = newValue
        }
      }
    }
  }
}

Then you can do the Shared transformations I outlined above.

I will repeat that I do not think you should keep this code for the long term. But, it can help you get past your current hurdles and then in the near future I recommend refactoring to use a proper IdentifiedArray.

[jiledaa]

Using identified array from the domain model sounds reasonable and works with it. Thank you for your support.

[morstin]

Dear @jiledaa,

I am struggeling with assigned a value to Shared Optionals. How do you assign a value to the shared user? I get a compiler error that Share cannot be assigned to Shared<User?>. When creating a shared user with Shared, user is not optional inside Shared. As you say you did it somewhere in the reducer. Would be great if you can share, how you did it!