Refactoring

Author: ra1028

Sources/Atoms/Core/StoreContext.swift

@@ -389,28 +389,19 @@ private extension StoreContext {
             dependency._loader.performTransitiveUpdate(subscription.update)
         }
 
-        // Do not transitively update atoms that have dependency recorded not to update downstream.
-        // However, if the topological sorting has already skipped the vertex as a redundant,
-        // it should be performed.
         func convertToValidEdge(_ edge: Edge) -> Edge? {
+            // Do not transitively update atoms that have dependency recorded not to update downstream.
             guard skippedDependencies.contains(edge.from) else {
                 return edge
             }
 
-            guard let redundantDependencies = redundants[edge.to] else {
+            // If the topological sorting has marked the vertex as a redundant, the update still performed.
+            guard let fromKey = redundants[edge.to]?.first(where: { !skippedDependencies.contains($0) }) else {
                 return nil
             }
 
-            // Topological sorting itself does not guarantee idempotent result when multiple
-            // dependencies update simultaneously and there's no valid update order to determine
-            // which atom triggered the transitive update, and thus here chooses a random
-            // dependency atom from redundant edges.
-            guard let fromKey = redundantDependencies.subtracting(skippedDependencies).first else {
-                return nil
-            }
-
-            // Convert edge's `from`, which represents a dependency atom, to a non-skipped one on
-            // a best-effort basis to switch the update transaction context (e.g. animation).
+            // Convert edge's `from`, which represents a dependency atom, to a non-skipped one to
+            // change the update transaction context (e.g. animation).
             return Edge(from: fromKey, to: edge.to)
         }
 

Sources/Atoms/Core/TopologicalSort.swift

@@ -12,11 +12,11 @@ internal struct Edge: Hashable {
 @MainActor
 internal func topologicalSort(key: AtomKey, store: AtomStore) -> (
     edges: ReversedCollection<[Edge]>,
-    redundants: [Vertex: Set<AtomKey>]  // key = vertex, value = dependencies
+    redundants: [Vertex: [AtomKey]]  // key = vertex, value = dependencies
 ) {
     var trace = Set<Vertex>()
     var edges = [Edge]()
-    var redundants = [Vertex: Set<AtomKey>]()
+    var redundants = [Vertex: [AtomKey]]()
 
     func traverse(key: AtomKey, isRedundant: Bool) {
         if let children = store.graph.children[key] {
@@ -43,7 +43,7 @@ internal func topologicalSort(key: AtomKey, store: AtomStore) -> (
         traverse(key: key, isRedundant: isRedundant)
 
         if isRedundant {
-            redundants[vertex, default: []].insert(fromKey)
+            redundants[vertex, default: []].append(fromKey)
         }
         else {
             let edge = Edge(from: fromKey, to: vertex)
@@ -58,7 +58,7 @@ internal func topologicalSort(key: AtomKey, store: AtomStore) -> (
         trace.insert(vertex)
 
         if isRedundant {
-            redundants[vertex, default: []].insert(fromKey)
+            redundants[vertex, default: []].append(fromKey)
         }
         else {
             let edge = Edge(from: fromKey, to: vertex)