When should withDependencies(from: self) be used?

[Zeta611]

I initially understood that when a model creates a child model, I always need to wrap the initialization of the child model with withDependencies(from: self), in order to properly hand down dependencies:

However, when constructing EditTodoModel inside the tappedTodo method, its dependencies will go back to the default liveValue that the application launches with. It will not have any of the overridden dependencies from when the TodosModel was created.

(from https://pointfreeco.github.io/swift-dependencies/main/documentation/dependencies/overridingdependencies/)

For instance, I have a following MWE:

import Dependencies
import SwiftUI
@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView(
                viewModel: withDependencies {
                    let calendar = Calendar.current
                    let comps = DateComponents(calendar: calendar, year: 2000, month: 1, day: 1)
                    $0.date.now = calendar.date(from: comps)!
                } operation: { ContentViewModel() }
            )
        }
    }
}
final class ContentViewModel: ObservableObject {
    private(set) var subviewModel: SubviewModel!
    init() { /****** HERE ******/ subviewModel = withDependencies(from: self) { SubviewModel() } }
}
struct ContentView: View {
    @ObservedObject private(set) var viewModel: ContentViewModel
    var body: some View { Subview(viewModel: viewModel.subviewModel) }
}
final class SubviewModel: ObservableObject {
    @Published private(set) var text: String = ""
    @Dependency(\.date) var date
    init() { text = date.now.formatted() }
}
struct Subview: View {
    @ObservedObject private(set) var viewModel: SubviewModel
    var body: some View { Text(viewModel.text) }
}

I overrode date to return a fixed date in a ContentViewModel (which doesn't use any dependency), which in turn propagates that to a SubviewModel.

However, withDependencies(from: self) warns me at run time:

You are trying to propagate dependencies to a child model from a model with no dependencies.
To fix this, the given 'ContentViewModel' must be returned from another 'withDependencies' closure,
or the class must hold at least one '@Dependency' property.

This is confusing because ContentViewModel was returned from a withDependencies closure in MyApp struct. What does another in another 'withDependencies' closure mean?

Indeed, I discovered that SubviewModel properly receives the overriden date from MyApp struct even without the withDependencies(from: self) closure.

Why does the SubviewModel gets a proper dependency even without the withDependencies(from: self) closure? Is it not okay to simply sprinkle withDependencies(from: self)s around? I just want to make sure all my dependencies are propagated to all deeply nested children.

[tgrapperon]

Hey @Zeta611. I agree that this can be a little confusing. Maybe some insight about the internals could make things clearer:

• When a @Dependency property wrapper is initialized, it internally captures the complete set of current DependencyValues, independently of the KeyPath it observes. This is not a general property of property wrappers, but something that was implemented on purpose. When a model instance is initialized, all its @Dependency property wrappers values (the _ values) are initialized. @Dependency is able to init itself from the KeyPath only, and that's why you don't need to pass a default value, and you don't see it, but it happens right before the model's init.
• withDependencies { $0.x = y } operation: { someOperation() } makes sure that the DependencyValues (which is a kind of static var) is properly set for the duration of operation. For example, it means that when you remove the withDependencies(from:) in the init, the child feature's init is still executing with the DependencyValues being set under MyApp's withDependencies's operation. So because the init is synchronous and not escaping, SubViewModel is initialized inside MyApp's withDependencies, and its @Dependency property wrappers are able to capture the current dependency values when they're created with the model's instance.
• When you use withDependencies(from: z), the framework tries to fish out the complete DependencyValues that were captured by any @Dependency property wrapper from z to forward them to the operation closure. It uses reflection, but for this to work, z must have at least one @Dependency property wrapper. This is the error message you're receiving: because ContentViewModel has no @Dependency, the framework doesn't know where to find a DependencyValues copy. The usual workaround is to install an unused @Dependency(\.self) var dependencies in ContentViewModel.

withDependencies(from:) is intended to be used with events that are not synchronous with models' init (which usually happen under some withDependencies {} or withDependencies(from:) regime where the DependencyValues are set). For example, when the user taps a button and you create some child model in response:

func onButtonTapped() {
  self.childModel = withDependencies(from: self) {
    ChildModel()
  }
}
// or
func onButtonTapped() {
  withDependencies(from: self) {
    self.childModel = ChildModel()
  }
}

This is roughly equivalent to the pseudo-code:

withDependencies {
  let currentModelDependencies = extractCompleteDependencyValuesFrom@DependencyInSelf()
  $0 = currentModelDependencies
} operation: {
  self.childModel = ChildModel()
}

In other words, you use withDependencies(from:) when you create a child model at a later time than the parent model's init. If you create the child model in the parent's model init, you don't need anything, as this init itself is already (supposedly) happening in the operation closure of some withDependencies { $0.… } or withDependencies(from:) upstream.

I hope it makes things clearer. Let me know if it doesn't.

[Zeta611]

Thank you for providing the internal details of how the library injects dependencies! This thorough explanation definitely made my understanding clearer.

Especially this part:

So because the init is synchronous and not escaping, SubViewModel is initialized inside MyApp's withDependencies, and its @dependency property wrappers are able to capture the current dependency values when they're created with the model's instance.

Thank you always for an amazing answer.