How to observe UserDefaults changes

[atacan]

Hello, the values method in @Dependency(\.userDefaults) is marked with @_spi(Internals).
What is the way to loop on that async sequence?

[atacan]

or was the plan to add it to the https://github.com/tgrapperon/swift-dependencies-additions/blob/main/Sources/UserDefaultsDependency/UserDefaults%2BSpecializations.swift for each type, similar to the get and set methods there?

[atacan]

I added them in this branch. After using it a bit, I can create a PR.
https://github.com/tgrapperon/swift-dependencies-additions/compare/main...atacan:tgrapperon-swift-dependencies-additions:userdefaults_stream?expand=1

[tgrapperon]

Hey @atacan!
The current way is to use the AppStorage experimental dependency. The values(forKey:) function is semi-private because the elements are existentials and there is then a lot of room to pass mismatched types.

That being said, and as I'm thinking about it again, it may be an omission. I think I forgot to get back to it once I implemented the corresponding functionality in AppStorage.

Your changes are close to what I had in mind, but I'm wondering if we could not tidy a little the API by erasing the async sequences to AsyncStream<Bool?>, etc. There are maybe alternative ways to name the functions (but I think that your choice leads the race). I'd be happy to review a PR based on your branch if you wouldn't mind.

[atacan]

Good point about the types. Would you do it like this?

private func existentialToConcrete<T>(_ asyncStreamAnySendable: AsyncStream<(any Sendable)?>)
  -> AsyncStream<T?>
{
  return AsyncStream<T?> { continuation in
    Task {
      for await value in asyncStreamAnySendable {
        if let valueAsT = value as? T {
          continuation.yield(valueAsT)
        }
      }
      continuation.finish()
    }
  }
}

then

public func doubleValues(forKey key: String) -> AsyncStream<Double?> {
  return existentialToConcrete(self._values(key, Double.self))
}

[tgrapperon]

Ha, it's probably simpler than this! There is an .eraseToStream() utility in Dependencies that does that. Async sequence operations are lazy by nature, so I don't think it causes any noticeable issue to simply erase the sequences you were exposing.
BTW, the implementation you had is not complete, because the Task you spawned is never cancelled, and the enumeration never stops. This is something you need to handle with onTermination from the continuation. You would simply need to get a handle to the Task and cancel it in the onTermination block. But I think it's simpler to use Dependencies' utility in our case.