Can I use Scope on property of child state struct?

[andwrobs]

Hi all,

I was trying to scope a nested property of a child state in a parent feature like so:

public var player: Player.State = .init(
    isAuthenticated: false,
    settings: Settings(
        ...
    ),
    profiles: [],
    selectedProfile: .none
)

Scope(state: \.player.settings, action: /Action.appDelegate) {
  AppDelegateReducer()
}

^ the above works if I lift up the settings struct into the top level AppFeature struct, and then reference it in scope as "settings" directly (like is shown in isowords and other examples) — but if I try to target just the property of the player child state, it doesn't appear I can get it returning in the KeyPath type I need.

Perhaps there's a way to do the mapping with some ReducerProtocol extensions? Any recommendations for this use case?

Thanks!!

---

EDIT: settings was an optional property of Player and that seems to be what was causing the issue

[tgrapperon]

Hey @andwrobs! You should think to Scope as an adapter between different domains. You have ParentState and ParentAction outside, and you have ChildState and ChildAction inside. And you provide the two transforms ParentState <-> ChildState and ParentAction <-> ChildAction with the two arguments of Scope.

In your case, Scope(state: \.player.settings, action: /Action.appDelegate) is expecting a ReducerProtocol<Settings.State, AppDelegateReducer.Action> child. Is AppDelegateReducer.State == Settings?

[andwrobs]

Is AppDelegateReducer.State == Settings?

it wasn't because it was optional!

You have ParentState and ParentAction outside, and you have ChildState and ChildAction inside. And you provide the two transforms ParentState <-> ChildState and ParentAction <-> ChildAction with the two arguments of Scope.

thank you for this clear writeup, i'll be passing on to my teammates too

[stephencelis]

@andwrobs Can you share more info about the error and your domain's types? E.g. what does var settings look like on Player.State. Is it a writable property?

Ah, seeing your "edit" now, have you tried using ifLet instead? I don't have a full picture of your domain, but you can maybe do something like:

Scope(state: \.player, action: .self) {
  Reduce { state, action in
    // core reducer logic
  }
  .ifLet(\.settings, action: /Action.appDelegate) {
    AppDelegateReducer()
  }
}

Or maybe even:

Reduce { state, action in
  // core reducer logic
}
.ifLet(\.player.settings, action: /Action.appDelegate) {
  AppDelegateReducer()
}

[andwrobs]

@stephencelis the intent is to model player.settings as an optional writable property that gets set to a non-nil value when settings are loaded from device, in this case using FileClient like you do in isowords.

theifLet syntax you suggested works, and I think it matches the intent well:

• carve out a logic domain for player & settings
• if and only if settings are successfully loaded (and are writeable to) — allow changes to settings

1 quick follow-up question: any suggestion for correctly using new syntax to avoid the below pictured deprecation warning?

"'buildFinalResult' is deprecated: Reducer bodies should return 'some ReducerProtocol<State, Action>' instead of 'Reduce<State, Action>'."

[stephencelis]

@andwrobs Those warnings can pop up due to a bug in Swift. We try to work around a bunch of them in the library, but it's not perfect. Any chance you can share a working slice of your domain so we can look into silencing that warning?

We may disable the warnings entirely in the future since we only have so much control over them...

[andwrobs]

We try to work around a bunch of them in the library, but it's not perfect

idk pretty close to perfect imo, you guys make Swift way easier to work with

Any chance you can share a working slice of your domain so we can look into silencing that warning?

below should work — if it's missing anything please let me know, hope it helps. thank you for the responses here!

public struct AppFeature: ReducerProtocol {
  
  public struct State: Equatable {
    public var player: Player.State = .init(
      settings: .none
    )
  }
  
  public enum Action: Equatable {
    case appDelegate(AppDelegateReducer.Action)
  }
  
  public init() {}
  
  enum AppCancelID {}
  
  public var body: some ReducerProtocol<State, Action> {
    self.core
    // ifLet some other things like Onboarding
  }
  
  @ReducerBuilder<State, Action>
  var core: some ReducerProtocol<State, Action> {
    
    Scope(state: \.player, action: .self) {
      Reduce { state, action in
        switch action {
          
        case .appDelegate(.settingsLoaded(.success(let settings))):
          // set player.settings
          return .none
          
        default:
          return .none
        }
      }
      .ifLet(\.settings, action: /Action.appDelegate) {
        AppDelegateReducer()
      }
    }
    
  }
}

public struct AppDelegateReducer: ReducerProtocol {
  public typealias State = Settings
  
  public enum Action: Equatable {
    case settingsLoaded(TaskResult<Settings>)
  }
  
  public init() {}
  
  public var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
      switch action {
        
      case let .settingsLoaded(_):
        return .none
        
      default:
        return .none
      }
    }
    
  }
}

public struct Player: ReducerProtocol {
  
  public struct State: Equatable {
    public var settings: Settings?
    // also includes isAuthenticated, profiles, selectedProfile, etc
  }
  
  public enum Action: Equatable { }
  
  public init() { }
  
  public var body: some ReducerProtocol<State, Action> {
    EmptyReducer()
  }
  
}

public struct Settings: Codable, Equatable {
  public var userSettings: UserSettings
  // public var gameSettings: GameSettings
  // ...
}

public struct UserSettings: Codable, Equatable {
  public var notification: Date.TimeOfDay? = .none
  // font size
  // sounds
  // ...
}

[saroar]

how do I handle nested Enum ?

public struct AppReducer: ReducerProtocol {
    public enum State: Equatable {
        case login(Login.State)
        case home(Home.State)
        public init() { self = .login(Login.State()) }
    }
    public enum Action {
        case onAppear        
        case login(Login.Action)
        case home(Home.Action)
        case appDelegate(AppDelegateReducer.Action)
        case didChangeScenePhase(ScenePhase)
        case paymentTransaction(StoreKitClient.PaymentTransactionObserverEvent)
        case verifyReceiptResponse(TaskResult<ReceiptFinalizationEnvelope>)
    }

public var body: some ReducerProtocol<State, Action> {
        StoreKitLogic()
        Reduce { state, action in

// what next 
            Scope(state: /State.home, action: /Action.appDelegate) {
                Reduce { state, action in
                  switch action {

                  case .appDelegate(.settingsLoaded(.success(let settings))):
                    // set player.settings
                    return .none

                  default:
                    return .none
                  }
                }
                .ifLet(\.settings, action: /Action.appDelegate) {
                  AppDelegateReducer()
                }
            }
   }
} 

// Home 
public struct Home: ReducerProtocol {
    public enum State: Equatable {
        case welcome(Welcome.State)
        case word(WordReducer.State)

        public init() { self = .welcome(Welcome.State()) }
    }

    public enum Action {
        case onAppear
        case welcome(Welcome.Action)
        case word(WordReducer.Action)
    }

How scope work with nested enums?

[tgrapperon]

The "equivalent" of [Writable]KeyPath for enums is CasePath. In this case, you should probably use the ifCaseLet modifier:

Reduce {
  …
}
.ifCaseLet(/State.welcome, action: /Action.welcome) {
  Welcome()
}
.ifCaseLet(/State.word, action: /Action.word) {
  WordReducer()
}

There is also a Scope(state: /State.word, action: /Action.word), but it has a few edge cases that .ifCaseLet hasn't.

[saroar]

my main problem is Scope AppDelegateReducer ?

public struct AppReducer: ReducerProtocol {
    public enum State: Equatable {
        case loginState: Login.State
        case transiteState: TransitReducer.State?
    }
}

public struct TransitReducer {
    public enum State: Equatable { -> Struct
        case register(Register.State)
        case word(WordReducer.State)
        public init() { self = .welcome(Welcome.State()) }
    }
}

public struct WordsReducer {
    struct State {
        var setting: Setting
    }
}

public struct Setting {
    struct State {
        @BindableState public var userSettings: UserSettings
    }
}

do you think it will be better to use Struct over enum

[tgrapperon]

The usual way to approach this problem is to ask yourself if the app can be have both states non-nil (or active) at the same time. If this is the case, then you should use a struct, otherwise, an enum can help you enforce this state's uniqueness.

So if TransitReducer's state is either register, or either .word, and never with a non-nil/active register AND word at the same time, then you can use an enum.

You could also use a struct with two optional properties, but you'll lose the guarantee that when one is non-nil, the other is nil.

If you're a subscriber of Point-Free, you can maybe have a look at the Structs 🤝 Enums episode for more information about the differences between these types.

[saroar]

Yes I am subscriber of Point-Free I will watch sure
its my mistake my login case should be optional here is process
1st time user see login screen then he move to register screen after he home to WordReducer screen
2nd he should direct to go WordReducer if he is already login + register

[tgrapperon]

Great, you can also watch this episode before then: https://www.pointfree.co/episodes/ep4-algebraic-data-types, as it is maybe the one I was thinking about.