Modifying parent state from child view controller?

[acosmicflamingo]

Let's say I have the following SettingsFeature module that has a userSettings struct in it:

public struct SettingsFeature: ReducerProtocol {
  struct State {
    var userSettings: UserSettings
  }
}

public struct UserSettings {
    var userInterfaceStyle: UIUserInterfaceStyle
}

The SettingsViewController that houses SettingsFeature allows presenting DarkModeViewController, which houses DarkModeFeature module:

public struct DarkModeFeature: ReducerProtocol {
  struct State {
    var userInterfaceStyle: UIUserInterfaceStyle
  }
}

Scoping/pullback would work if SettingsFeature had DarkModeFeature in its state. However, I only want to pass a subset of SettingsFeature's state to DarkModeViewController so DarkModeFeature can modify the userInterfaceStyle. Is it possible for me to modify SettingsFeature.State's userSettings within DarkModeViewController?

[stephencelis]

@acosmicflamingo If you're looking to isowords as an example here, we'd like to warn you that we'd probably do it differently the second time around. Having settings domain live and shared in state ended up being pretty cumbersome with a lot of boilerplate. We'd like to eventually refactor settings to be more of a dependency, like UserDefaults, that is accessed at nodes that need it to hydrate UI that needs to reflect it.

[mbrandonw]

The dependency should be something more like a UserSettingsClient rather than UserSettings directly, and internally it can manage a bit of mutable storage:

struct UserSettingsClient {
  var colorScheme: () -> ColorScheme
  var setColorScheme: (ColorScheme) -> Void
  var someOtherSetting: () -> Int
  var setSomeOtherSetting: (Int) -> Void
}

extension UserSettingsClient {
  static var live: Self {
    var colorScheme = ColorScheme.light
    var someOtherSetting= 42
    return Self(
      colorScheme: { colorScheme },
      setColorScheme: { colorScheme = $0 },
      someOtherSetting: { someOtherSetting },
      setSomeOtherSetting: { someOtherSetting = $0 }
    )
  }
}

In fact, at that point, maybe it should just be using user defaults under the hood so that you get instant persistence?

Also, the above code is not safe in a concurrency world. Really the settings should be wrapped up in some kind of isolated data type to make it safe. An actor would be easiest, but then that would make everything async, which is good for the setXYZ endpoints but not very user friendly for the getters.

A way to make this concurrency safe and ergonomic is to not use an actor, but rather use a lock. Basically you could have a kind of LockIsolated<Value> type similar to our ActorIsolated data type. That would allow get to be sync, but you would probably still want set to be async.

[pyrtsa]

That would allow get to be sync, but you would probably still want set to be async.

Did you mean set to be async here (and get to be sync)?

[pyrtsa]

If the (current) user settings were recovered by reducers via an injected dependency like

struct UserSettingsClient {
  var colorScheme: () -> ColorScheme
  var setColorScheme: (ColorScheme) -> Void
  // ...
}

how then would a reducer then observe the color scheme changes when another reducer (such as a currently visible child view of the current view) changed it?

[mbrandonw]

Did you mean set to be async here (and get to be sync)?

That's correct. We think reading a bit of mutable state from a dependency is fine to be sync (see more explanation here), but writing should be async so that it forces you to access it from within an Effect rather than calling directly in a reducer.

how then would a reducer then observe the color scheme changes when another reducer (such as a currently visible child view of the current view) changed it?

You would expose additional endpoints for long living effects that emit when the state changes:

struct UserSettingsClient {
  …
  var settingsDidUpdate: () -> AsyncStream<Void>
}

This is just a sketch of the possibilities. There are more directions one can go to make the API nicer, but it's the basics. For one thing, AsyncStream does not support multiple subscribers, so you may need to internally keep track of an array of them, or use something that does support that like AsyncChannel (or maybe even go back to using Effect directly).

[acosmicflamingo]

Thanks for the thorough response!

In fact, at that point, maybe it should just be using user defaults under the hood so that you get instant persistence?

Actually, I was originally going to use UserDefaults for local persistence. However, I noticed in isowords that you were actually saving ColorScheme indirectly by conforming UserSettings struct to Codable protocol and then saving that encoded data onto local storage.

I thought it was strange that you'd go that route when UserDefaults was something you utilized elsewhere in isowords, until I tried it myself. I had to first make ColorScheme conform to Int enum type, which would allow me to utilize UserDefaultsClient's setInt closure. I then thought this involves more boilerplate logic than I expected, which led me to believe isowords went the local persistence route because it's cleaner to just save and load an instance of a UserSettings struct instead of having to add support for every single new struct that we want to save in UserDefaults.

Does that mean that I'm going to have to update UserDefaultsClient and UserSettings Client accordingly for every attribute I want to save locally?

// Code isn't utilizing async; written just to demonstrate how to utilize UserDefaults under the hood
struct UserSettingsClient {
  var userDefaultsClient: UserDefaultsClient
  var colorScheme: () -> ColorScheme
  var setColorScheme: (ColorScheme) -> Void
}

extension UserSettingsClient {
  static var live: Self {
    var colorScheme = ColorScheme.light
    return Self(
      colorScheme: { userDefaultsClient.colorScheme },
      setColorScheme: { userDefaultsClient.setColorScheme($0) }
    )
  }
}

public struct UserDefaultsClient {
  public var integerForKey: (String) -> Int
  public var setInteger: (Int, String) -> Effect<Never, Never>
  ...
  public var colorScheme: ColorScheme {
    let val = integerForKey(colorSchemeKey)
    return ColorScheme(rawValue: val) ?? .unspecified
  }

  public func setColorScheme(
    _ colorScheme: ColorScheme
  ) -> Effect<Never, Never> {
    setInteger(colorScheme.rawValue, colorSchemeKey)
  }
}

let colorSchemeKey = "colorSchemeKey"

[acosmicflamingo]

Thank you everyone for the help; I would not have figured it out without all the comments!

In case anyone wants to know how I approached it, here is some code:

UserSettingsClient logic

public struct UserSettingsClient {
  public var colorScheme: () -> ColorScheme
  public var setColorScheme: (ColorScheme) async -> Void
  public var refreshUserInterfaceStyle: (ColorScheme) -> Void
  var userDefaults: UserDefaultsClient

  public enum ColorScheme: Int, CaseIterable, Codable {
    case system
    case dark
    case light

    public var userInterfaceStyle: UIUserInterfaceStyle {
      switch self {
      case .system:
        return .unspecified

      case .dark:
        return .dark

      case .light:
        return .light
      }
    }

  public static var live: Self {
    let userDefaults = UserDefaultsClient.live

    return Self(
      colorScheme: {
        let rawValue = userDefaults.integerForKey(colorSchemeKey)
        return ColorScheme(rawValue: rawValue) ?? .system
      },
      setColorScheme: {
        let rawValue = $0.rawValue
        await userDefaults.setInteger(rawValue, colorSchemeKey)
      },
      refreshUserInterfaceStyle: { colorScheme in
        let scenes = UIApplication.shared.connectedScenes
        if let windowScene = scenes.first as? UIWindowScene {
          for window in windowScene.windows {
            window.overrideUserInterfaceStyle = colorScheme.userInterfaceStyle
          }
        }
      },
      userDefaults: userDefaults
    )
  }

  #if DEBUG
    public static var unimplemented: Self {
      return Self(
        colorScheme: XCTUnimplemented("\(Self.self).colorScheme is unimplemented"),
        setColorScheme: XCTUnimplemented("\(Self.self).setColorScheme is unimplemented"),
        refreshUserInterfaceStyle: XCTUnimplemented(
          "\(Self.self).setColorScheme is unimplemented"
        ),
        userDefaults: .unimplemented
      )
    }
  #endif
}

let colorSchemeKey = "colorSchemeKey"

extension DependencyValues {
  public var userSettings: UserSettingsClient {
    get { self[UserSettingsClientKey.self] }
    set { self[UserSettingsClientKey.self] = newValue }
  }

  private enum UserSettingsClientKey: DependencyKey {
    static var liveValue = UserSettingsClient.live
    static var testValue = UserSettingsClient.unimplemented
  }
}

UserDefaults logic:

public struct UserDefaultsClient {
  public var boolForKey: (String) -> Bool
  public var dataForKey: (String) -> Data?
  public var doubleForKey: (String) -> Double
  public var integerForKey: (String) -> Int
  public var remove: (String) async -> Void
  public var setBool: (Bool, String) async -> Void
  public var setData: (Data?, String) async -> Void
  public var setDouble: (Double, String) async -> Void
  public var setInteger: (Int, String) async -> Void

  public var hasShownFirstLaunchOnboarding: Bool {
    self.boolForKey(hasShownFirstLaunchOnboardingKey)
  }

  public func setHasShownFirstLaunchOnboarding(_ bool: Bool) async {
    await self.setBool(bool, hasShownFirstLaunchOnboardingKey)
  }

  public var installationTime: Double {
    self.doubleForKey(installationTimeKey)
  }

  public func setInstallationTime(_ double: Double) async {
    await self.setDouble(double, installationTimeKey)
  }

  public init(
    boolForKey: @escaping (String) -> Bool,
    dataForKey: @escaping (String) -> Data?,
    doubleForKey: @escaping (String) -> Double,
    integerForKey: @escaping (String) -> Int,
    remove: @escaping (String) async -> Void,
    setBool: @escaping (Bool, String) async -> Void,
    setData: @escaping (Data?, String) async -> Void,
    setDouble: @escaping (Double, String) async -> Void,
    setInteger: @escaping (Int, String) async -> Void
  ) {
    self.boolForKey = boolForKey
    self.dataForKey = dataForKey
    self.doubleForKey = doubleForKey
    self.integerForKey = integerForKey
    self.remove = remove
    self.setBool = setBool
    self.setData = setData
    self.setDouble = setDouble
    self.setInteger = setInteger
  }
}

let hasShownFirstLaunchOnboardingKey = "hasShownFirstLaunchOnboardingKey"
let installationTimeKey = "installationTimeKey"

DarkModeFeature:

public struct DarkModeFeature: ReducerProtocol {
  public struct State: Equatable {
    var colorScheme: UserSettingsClient.ColorScheme

    public init(colorScheme: UserSettingsClient.ColorScheme) {
      self.colorScheme = colorScheme
    }
  }

  public enum Action: Equatable {
    case systemModeButtonTapped
    case darkModeButtonTapped
    case lightModeButtonTapped
    case userSettingsUpdateResponse(UserSettingsClient.ColorScheme)
  }

  public func reduce(into state: inout State, action: Action) -> Effect<Action, Never> {
    switch action {

    case .systemModeButtonTapped:
      return .run { send in
        let colorScheme: UserSettingsClient.ColorScheme = .system
        await userSettings.setColorScheme(colorScheme)
        await send(.userSettingsUpdateResponse(colorScheme))
      }

    case .darkModeButtonTapped:
      return .run { send in
        let colorScheme: UserSettingsClient.ColorScheme = .dark
        await userSettings.setColorScheme(colorScheme)
        await send(.userSettingsUpdateResponse(colorScheme))
      }

    case .lightModeButtonTapped:
      return .run { send in
        let colorScheme: UserSettingsClient.ColorScheme = .light
        await userSettings.setColorScheme(colorScheme)
        await send(.userSettingsUpdateResponse(colorScheme))
      }

    case let .userSettingsUpdateResponse(colorScheme):
      state.colorScheme = colorScheme
      userSettings.refreshUserInterfaceStyle(colorScheme)
      return .none
    }
  }

  @Dependency(\.userSettings) var userSettings

  public init() {}
}

Goes without saying that this is all pretty much either from Isowords, the ReducerProtocol discussion, the concurrency discussion, or the discussion above. My only contribution is coming up with the action names I suppose ;)

[acosmicflamingo]

To add, here's accompanying tests that demonstrate how absolutely testable this all is:

import ComposableArchitecture
import Foundation
import SwiftUI
import UserDefaultsClient
import UserSettingsClient
import XCTest

@testable import DarkModeFeature

@MainActor
final class DarkModeFeatureTests: XCTestCase {
  func testUpdatingUserInterfaceStyle() async {
    let store = TestStore(
      initialState: DarkModeFeature.State(colorScheme: .system),
      reducer: DarkModeFeature()
    )
    var newColorScheme: UserSettingsClient.ColorScheme = .system
    var refreshedInterfaceStyle: UIUserInterfaceStyle = .unspecified
    var savedValue = 0

    var userDefaults = UserDefaultsClient.unimplemented
    userDefaults.setInteger = { value, key in
      savedValue = value
    }
    store.dependencies.userSettings = UserSettingsClient(
      colorScheme: { .system },
      setColorScheme: { colorScheme in
        newColorScheme = colorScheme
        await userDefaults.setInteger(newColorScheme.rawValue, "")
      },
      refreshUserInterfaceStyle: { colorScheme in
        refreshedInterfaceStyle = colorScheme.userInterfaceStyle
      },
      userDefaults: userDefaults
    )

    _ = await store.send(.systemModeButtonTapped)
    XCTAssertEqual(newColorScheme, .system)
    await store.receive(.userSettingsUpdateResponse(.system))
    XCTAssertEqual(refreshedInterfaceStyle, .unspecified)
    XCTAssertEqual(savedValue, UserSettingsClient.ColorScheme.system.rawValue)

    _ = await store.send(.lightModeButtonTapped)
    XCTAssertEqual(newColorScheme, .light)
    await store.receive(.userSettingsUpdateResponse(.light)) {
      $0.colorScheme = .light
    }
    XCTAssertEqual(refreshedInterfaceStyle, .light)
    XCTAssertEqual(savedValue, UserSettingsClient.ColorScheme.light.rawValue)

    _ = await store.send(.darkModeButtonTapped)
    XCTAssertEqual(newColorScheme, .dark)
    await store.receive(.userSettingsUpdateResponse(.dark)) {
      $0.colorScheme = .dark
    }
    XCTAssertEqual(refreshedInterfaceStyle, .dark)
    XCTAssertEqual(savedValue, UserSettingsClient.ColorScheme.dark.rawValue)
  }
}

TCA leaves no stone unturned! Absolutely amazing how robust this architecture is.