Just as an FYI to any readers... my "solution" to this problem was to provide a function on my object (i.e. an instance of a class) which owns the state data (i.e. an instance of a struct). The struct provides 2 functions, a non-mutating one which gets cached data via a key, and a second which is marked mutating. The second one checks the cache and returns the cached data (without modifying state), but if it is not in the cache it computes it and adds it to the cache (thereby modifying state). Only the owning object ever calls these two functions, and it does so from the method it exposes, first trying the non-mutating method and only calling the mutating method if the requested data was not in the cache.
This is ugly and inefficient (multiple mutex locks are required), but appears to be forced upon me by the language / framework design. I would like to have a better solution.
struct D {
		func get_cached(key: Int) -> ValueType { ... }
		mutating func create_cached(key: Int) -> ValueType { ... }		 // always causes a SwiftUI update
}
class A {
		var data : D
		func get_value(key: Int) {
				if let value = data.get_cached(key) {
						return value
				}
				else {
						return data.create_cached(key)
				}
}
