Derived state performance

[PierreCapo]

Sometimes we want some state value to derive from other ones, but I can not find the correct approach in case of performance issues.

1. Computed property approach (example in isoword)

struct AppState: Equatable {
  var data: [Int]
  var someFilters: [Int]
   
  // variable which depends on a and B
  // pointsOfInterests is used in a lot of places in the UI and in the reducers.
  var pointsOfInterests: [Int] {
    return a.filter { ... }.filter { b.contains($0) }....
  }
}

❌ Problem: pointsOfInterests gets recalculated every time it is accessed by the UI. I am working on a scenario with a map, so the UI is refreshed continuously whenever the user drag the map, meaning that pointOfInterest as a computed property is evaluated a lot of time and makes the app lag.

2. Actions in reducer

struct AppState: Equatable {
  var data: [Int]
  var someFilters: [Int]
   
  // variable which depends on data and someFilters
  var pointsOfInterests: [Int] 
  
  func evaluatePointOfInterests() -> [Int] {
    return data.filter { ... }.filter { someFilters.contains($0) }....
  }
}

// reducer code
 switch(action) {
   case let .populateData(data):
     state.data = data
     state.pointsOfInterests = evaluatePointOfInterests(data)
     
   case let .editFilters(filters):
     state.someFilters = filters
     state.pointsOfInterests = evaluatePointOfInterests(data)
}

❌ Problem: It fixes the performance issue because pointsOfInterests is only recomputed when data or someFilters changes. However this introduce a cohesion issue where you need to not forget to update pointsOfInterests when you update data or someFilters which is not scalable in the long-term run.

My question: What is the pattern to only recompute a derived state only when its dependencies change to avoid performance issues ?

With a more familiar approach a bit a la Combine:

// Given that `data` and `someFilters` are observables
 Publishers.CombineLatest(data, someFilters)
   .sink { [weak self] in
     self?.pointsOfInterests = data.filter { ... }.filter { someFilters.contains($0) }....
   }
   .store(in: &cancellables)

pointOfInterests is only recomputed when its "dependencies" change and keep the cohesion integrity in the code 👍

Thanks in advance.

[Alex293]

You could make custom setters or property observers on the dependencies and a private setter on the the result.

struct AppState: Equatable {
  var data: [Int] {
    didSet {
      updatePOI()
    }
  }
  var someFilters: [Int] {
    didSet {
      updatePOI()
    }
  }

  private func updatePOI() {
    pointsOfInterests = data.filter { ... }.filter { someFilters.contains($0) }....
  }
  private (set) var pointsOfInterests: [Int] = []
}

You still have to manually update the state but at least it's done in a single place, transparent to reducers

[PierreCapo]

Oh that's correct, I forgot also this alternative which is a better version of my second alternative. Still though, I am not convinced by it for the cohesion part: we will still have the pointsOfInterests related code spread in multiple places and that doesn't look as clean as the Combine alternative (we can easily miss to add a didSet function)