How to scope single property of parent state to child state?

[acosmicflamingo]

Right now I have a parent Settings.State with the property userSettings, and I want to scope this single value to FontManager.State, but I can't figure out how to do this (I essentially want to make fontManager update userSettings.appFont so I don't really need userSettings actually).

public struct Settings: ReducerProtocol {
  public struct State: Equatable {
    public var userSettings: UserSettings
    public var fontManager: FontManager.State

    public init(
      userSettings: UserSettings = .init(),
      fontManager: FontManager.State = .init()
    ) {
      self.userSettings = userSettings
      self.fontManager = fontManager
      // self.fontManager.userSettings = userSettings      <== this will ignore updates so it only works in init 
    }
  }

Although I could use getter/setter logic so I don't pass Settings.State a FontManager.State value, this doesn't seem right because I should be able to pass Settings.State.init the FontManager.State if I wanted to. However, doing so means that there will now be two copies of userSettings, and that is not right either (which is right now the source of my problems).

The closest example I can find to what I'm trying to do comes from isowords: https://github.com/pointfreeco/isowords/blob/main/Sources/GameFeature/GameFeature.swift#L32 and https://github.com/pointfreeco/isowords/blob/main/Sources/GameCore/GameCore.swift#L534. However, I don't think I've seen any official documentation on this approach, so it could be a workaround to a problem that currently doesn't have a clean solution.

[junjielu]

You can do it in this way, although there will be some boilerplate code for the application.

public struct State: Equatable {
  public var userSettings: UserSettings
  private var _fontManager: FontManager.State
  public var fontManager: FontManager.State {
    get {
      var state = _fontManager
      state.appFont = userSettings.appFont
      return state
    }
    set {
      _fontManager = newValue
      userSettings.appFont = newValue.appFont
    }
  }

  public init(
    userSettings: UserSettings = .init(),
    fontManager: FontManager.State = .init()
  ) {
    self.userSettings = userSettings
    self._fontManager = fontManager
  }
}

[acosmicflamingo]

Well that certainly does the trick :D Normally this approach would seem too boilerplate-y for me but I haven't found a better, cleaner way so I'll go with this solution for now. If I do end up finding a cleaner way to do this, I'll post it here and mark it as an answer. Thank you @junjielu :)

[atimca]

Here's another example of @junjielu solution. We've discussed a bit in a team a proposed one. However, several concerns were made in terms of data synchronization. For example fontManger's appFont is always ignored, cause inside get we always rewrite appFont, so no matter which data you provide in init it'll be ignored. Also, this approach is a bit wordy because everything is happening inside State itself. There's a possibility to do it inside extensions, but private nature of _fontManageer brings some limitation.

In a team we come up with something similar but a bit different. For example in our case we have a property numberOfItemsInPaymentCart which is shared across several states. So we created internal versions of needed states, but without an extra parameter.

Inside main state things look like this.

struct AppFeature: ReducerProtocol {
    struct State: Equatable {
        var myMarktplaatsInternal: MyMarktplaatsFeature.State.Internal
        var paymentCartInternal: PaymentCartFeature.State.Internal
        var numberOfItemsInPaymentCart: Int
    }
}

We do create an extension of AppState with a needed leaf states and as you can see we store inside AppState only internal states with non-shared fields.

extension AppFeature.State {
    var paymentCart: PaymentCartFeature.State {
        get {
            PaymentCartFeature.State(
                internalState: paymentCartInternal,
                numberOfItemsInPaymentCart: numberOfItemsInPaymentCart
            )
        }
        set {
            paymentCartInternal = .init(state: newValue)
            numberOfItemsInPaymentCart = newValue.numberOfItems
        }
    }
}

extension PaymentCartFeature.State {
    init(
        internalState: Internal,
        numberOfItemsInPaymentCart: Int
    ) {
        self.init(
            numberOfItems: numberOfItemsInPaymentCart,
            shouldShowTooltip: internalState.shouldShowTooltip
        )
    }
}

extension PaymentCartFeature.State {
    struct Internal: Equatable {
        var shouldShowTooltip: Bool

        init() {
            self.shouldShowTooltip = false
        }

        init(state: PaymentCartFeature.State) {
            self.shouldShowTooltip = state.shouldShowTooltip
        }
    }
}

The result proposal is even more wordy than the previous one. However, it's quite simple to extract things into separate files. Also, no questions left about data synchronization.

I believe both of the proposed solutions make total sense. You just choose the one which is more suitable for the task.

[acosmicflamingo]

@atimca oh wow that's a great approach too! Thank you very much :) I'll definitely be experimenting with these solutions!

[atimca]

You're welcome 😀