I also struggled with this and found a very nice and clean solution: You have to wrap the row in a separate view and use @ObservedObject in that row view on the entity. Here’s my code: WineList: struct WineList: View { @FetchRequest(entity: Wine.entity(), sortDescriptors: [ NSSortDescriptor(keyPath: \Wine.name, ascending: true) ] ) var wines: FetchedResults<Wine> var … Read more
You have 2 problems here: 1. like @matt said, your publisher isn’t living long enough. You can either store the AnyCancellable as an instance var, or what I like to do (and appears to be a redux best practice) is use store(in:) to a Set<AnyCancellable> to keep it around and have it automatically cleaned up … Read more
You (Matt) probably know at least some of this already, but here are some facts for other readers: Swift infers types on one whole statement at a time, but not across statements. Swift allows type inference to automatically promote an object of type T to type Optional<T>, if necessary to make the statement type-check. Swift … Read more
try making a Group { } around your views. just 10 are allowed in Swiftui…with group you can add more. or use subviews…(would be cleaner code too)
SwfitUI has a pattern for this. It needs to conform custom view to Equatable protocol struct CustomView: View, Equatable { static func == (lhs: CustomView, rhs: CustomView) -> Bool { // << return yes on view properties which identifies that the // view is equal and should not be refreshed (ie. `body` is not rebuilt) … Read more
This is very well explained in WWDC 2019 video 415. You are merely looking at one special case of a broad language feature, namely property wrappers. A property wrapper (such as @State) is actually a way of referring to an instance of a type (usually a struct or enum) with the same name (such as … Read more
With your latest edit and this comment below: I literally am asking is there a Combine equivalent of “don’t proceed to the next step until this step, involving multiple asynchronous steps, has finished” I think this pattern can be achieved with .flatMap to an array publisher (Publishers.Sequence), which emits one-by-one and completes, followed by whatever … Read more
Use flatMap(maxPublishers:transform:) with .max(1), e.g. func imagesPublisher(for urls: [URL]) -> AnyPublisher<UIImage, URLError> { Publishers.Sequence(sequence: urls.map { self.imagePublisher(for: $0) }) .flatMap(maxPublishers: .max(1)) { $0 } .eraseToAnyPublisher() } Where func imagePublisher(for url: URL) -> AnyPublisher<UIImage, URLError> { URLSession.shared.dataTaskPublisher(for: url) .compactMap { UIImage(data: $0.data) } .receive(on: RunLoop.main) .eraseToAnyPublisher() } and var imageRequests: AnyCancellable? func fetchImages() { imageRequests = … Read more
Nested models does not work yet in SwiftUI, but you could do something like this class SubModel: ObservableObject { @Published var count = 0 } class AppModel: ObservableObject { @Published var submodel: SubModel = SubModel() var anyCancellable: AnyCancellable? = nil init() { anyCancellable = submodel.objectWillChange.sink { [weak self] (_) in self?.objectWillChange.send() } } } Basically … Read more