Refactoring

Author: ra1028

Sources/Atoms/Core/Loader/AtomLoader.swift

@@ -18,18 +18,18 @@ public protocol AtomLoader {
 
     /// Returns a boolean value indicating whether it should notify updates downstream
     /// by checking the equivalence of the given old value and new value.
-    func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool
+    func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool
 
-    /// Performs atom update.
-    func performPropagativeUpdate(_ body: () -> Void)
+    /// Performs transitive update for dependent atoms .
+    func performTransitiveUpdate(_ body: () -> Void)
 }
 
 public extension AtomLoader {
-    func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool {
+    func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool {
         true
     }
 
-    func performPropagativeUpdate(_ body: () -> Void) {
+    func performTransitiveUpdate(_ body: () -> Void) {
         body()
     }
 }

Sources/Atoms/Core/Loader/ModifiedAtomLoader.swift

@@ -27,13 +27,13 @@ public struct ModifiedAtomLoader<Node: Atom, Modifier: AtomModifier>: AtomLoader
 
     /// Returns a boolean value indicating whether it should notify updates downstream
     /// by checking the equivalence of the given old value and new value.
-    public func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool {
-        modifier.shouldPropagateUpdate(newValue: newValue, oldValue: oldValue)
+    public func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool {
+        modifier.shouldUpdateTransitively(newValue: newValue, oldValue: oldValue)
     }
 
-    /// Performs atom update.
-    public func performPropagativeUpdate(_ body: () -> Void) {
-        modifier.performPropagativeUpdate(body)
+    /// Performs transitive update for dependent atoms .
+    public func performTransitiveUpdate(_ body: () -> Void) {
+        modifier.performTransitiveUpdate(body)
     }
 }
 

Sources/Atoms/Core/StoreContext.swift

@@ -340,8 +340,8 @@ private extension StoreContext {
     ) {
         store.state.caches[key] = AtomCache(atom: atom, value: newValue)
 
-        // Check if the atom should propagate the update to downstream.
-        guard atom._loader.shouldPropagateUpdate(newValue: newValue, oldValue: oldValue) else {
+        // Check whether if the dependent atoms should be updated transitively.
+        guard atom._loader.shouldUpdateTransitively(newValue: newValue, oldValue: oldValue) else {
             return
         }
 
@@ -351,7 +351,7 @@ private extension StoreContext {
         atom.updated(newValue: newValue, oldValue: oldValue, context: context)
 
         // Calculate topological order for updating downstream efficiently.
-        let (edges, omitted) = topologicalSort(key: key, store: store)
+        let (edges, redundant) = topologicalSort(key: key, store: store)
         var skippingFrom = Set<AtomKey>()
 
         // Updates the given atom.
@@ -364,8 +364,8 @@ private extension StoreContext {
             let override = lookupOverride(of: atom)
             let newCache = makeCache(of: atom, for: key, override: override)
 
-            // Skip if the atom should not propagate update to downstream.
-            guard atom._loader.shouldPropagateUpdate(newValue: newCache.value, oldValue: cache.value) else {
+            // Check whether if the dependent atoms should be updated transitively.
+            guard atom._loader.shouldUpdateTransitively(newValue: newCache.value, oldValue: cache.value) else {
                 // Record the atom to avoid downstream from being update.
                 skippingFrom.insert(key)
                 return
@@ -379,14 +379,14 @@ private extension StoreContext {
 
         // Performs update of the given atom with the parent's context.
         func performUpdate(atom: some Atom, for key: AtomKey, dependency: some Atom) {
-            dependency._loader.performPropagativeUpdate {
+            dependency._loader.performTransitiveUpdate {
                 update(atom: atom, for: key)
             }
         }
 
         // Performs update of the given subscription with the parent's context.
         func performUpdate(subscription: Subscription, dependency: some Atom) {
-            dependency._loader.performPropagativeUpdate(subscription.update)
+            dependency._loader.performTransitiveUpdate(subscription.update)
         }
 
         // Do not transitively update atoms that have parent recorded not to update downstream.
@@ -397,24 +397,24 @@ private extension StoreContext {
                 return edge
             }
 
-            guard let omittedFrom = omitted[edge.to] else {
+            guard let redundantFrom = redundant[edge.to] else {
                 return nil
             }
 
-            guard let fromKey = omittedFrom.subtracting(skippingFrom).first else {
+            guard let fromKey = redundantFrom.subtracting(skippingFrom).first else {
                 return nil
             }
 
-            // Switch atom update transaction context (e.g. animation) to a non-skipped one on
-            // a best-effort basis.
-            // Topological sorting itself does not always produce an idempotent result when multiple
+            // Convert edge's `from`, which represents a dependent atom, to a non-skipped one on
+            // a best-effort basis to switch the update transaction context (e.g. animation).
+            // Topological sorting itself does not guarantee idempotent result when multiple
             // dependencies of an atom update simultaneously and there's no valid update order rule to
             // determine which atom produced the transitive update, and thus here chooses a random
-            // dependent atom from omitted ones.
+            // dependent atom from redundant edges.
             return Edge(from: fromKey, to: edge.to)
         }
 
-        // Performs atom updates ahead of notifying updates to subscriptions.
+        // Performs transitive update for dependent atoms s ahead of notifying updates to subscriptions.
         for edge in edges {
             switch edge.to {
             case .atom(let key):

Sources/Atoms/Core/TopologicalSort.swift

@@ -0,0 +1,69 @@
+internal enum Vertex: Hashable {
+    case atom(key: AtomKey)
+    case subscriber(key: SubscriberKey)
+}
+
+internal struct Edge: Hashable {
+    let from: AtomKey
+    let to: Vertex
+}
+
+/// DFS topological sorting.
+@MainActor
+internal func topologicalSort(key: AtomKey, store: AtomStore) -> (
+    edges: ReversedCollection<[Edge]>,
+    redundant: [Vertex: Set<AtomKey>]  // key = vertex, value = dependencies
+) {
+    var trace = Set<Vertex>()
+    var edges = [Edge]()
+    var redundant = [Vertex: Set<AtomKey>]()
+
+    func traverse(key: AtomKey, isRedundant: Bool) {
+        if let children = store.graph.children[key] {
+            for child in ContiguousArray(children) {
+                // Do not stop traversing downstream even when edges are already traced
+                // to analyze the redundant edges later.
+                let isRedundant = isRedundant || trace.contains(.atom(key: child))
+                traverse(key: child, from: key, isRedundant: isRedundant)
+            }
+        }
+
+        if let subscriptions = store.state.subscriptions[key] {
+            for subscriberKey in ContiguousArray(subscriptions.keys) {
+                let vertex = Vertex.subscriber(key: subscriberKey)
+
+                if isRedundant || trace.contains(.subscriber(key: subscriberKey)) {
+                    redundant[vertex, default: []].insert(key)
+                }
+                else {
+                    let edge = Edge(from: key, to: vertex)
+                    edges.append(edge)
+                }
+
+                trace.insert(.subscriber(key: subscriberKey))
+            }
+        }
+    }
+
+    func traverse(key: AtomKey, from fromKey: AtomKey, isRedundant: Bool) {
+        trace.insert(.atom(key: key))
+        traverse(key: key, isRedundant: isRedundant)
+
+        let vertex = Vertex.atom(key: key)
+
+        if isRedundant {
+            redundant[vertex, default: []].insert(fromKey)
+        }
+        else {
+            let edge = Edge(from: fromKey, to: vertex)
+            edges.append(edge)
+        }
+    }
+
+    traverse(key: key, isRedundant: false)
+
+    return (
+        edges: edges.reversed(),
+        redundant: redundant
+    )
+}

Sources/Atoms/Core/TopologicalSorting.swift

@@ -70,8 +70,8 @@ public struct AnimationModifier<T>: AtomModifier {
         value
     }
 
-    /// Performs atom update.
-    public func performPropagativeUpdate(_ body: () -> Void) {
+    /// Performs transitive update for dependent atoms .
+    public func performTransitiveUpdate(_ body: () -> Void) {
         withAnimation(animation, body)
     }
 }

Sources/Atoms/Modifier/AnimationModifier.swift

@@ -36,19 +36,19 @@ public protocol AtomModifier {
     /// Returns a boolean value indicating whether it should notify updates downstream
     /// by checking the equivalence of the given old value and new value.
     @MainActor
-    func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool
+    func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool
 
-    /// Performs atom update.
+    /// Performs transitive update for dependent atoms .
     @MainActor
-    func performPropagativeUpdate(_ body: () -> Void)
+    func performTransitiveUpdate(_ body: () -> Void)
 }
 
 public extension AtomModifier {
-    func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool {
+    func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool {
         true
     }
 
-    func performPropagativeUpdate(_ body: () -> Void) {
+    func performTransitiveUpdate(_ body: () -> Void) {
         body()
     }
 }

Sources/Atoms/Modifier/AtomModifier.swift

@@ -59,7 +59,7 @@ public struct ChangesModifier<T: Equatable>: AtomModifier {
 
     /// Returns a boolean value that determines whether it should notify the value update to
     /// watchers with comparing the given old value and the new value.
-    public func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool {
+    public func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool {
         newValue != oldValue
     }
 }

Sources/Atoms/Modifier/ChangesModifier.swift

@@ -69,7 +69,7 @@ public struct ChangesOfModifier<BaseValue, T: Equatable>: AtomModifier {
 
     /// Returns a boolean value that determines whether it should notify the value update to
     /// watchers with comparing the given old value and the new value.
-    public func shouldPropagateUpdate(newValue: Value, oldValue: Value) -> Bool {
+    public func shouldUpdateTransitively(newValue: Value, oldValue: Value) -> Bool {
         newValue != oldValue
     }
 }

Sources/Atoms/Modifier/ChangesOfModifier.swift

@@ -666,7 +666,7 @@ final class StoreContextTests: XCTestCase {
         XCTAssertEqual(scoped2Context.watch(atom, subscriber: subscriber, subscription: Subscription()), 21)
         XCTAssertEqual(scoped2Context.watch(publisherAtom, subscriber: subscriber, subscription: Subscription()), .suspending)
 
-        // Should set the value and then propagate it to the dependent atoms..
+        // Should set the value and then update the dependent atoms transitively.
         scoped2Context.set(20, for: dependency1Atom)
 
         // Should set the value because the atom depends on the shared `dependency1Atom`.
@@ -1150,7 +1150,7 @@ final class StoreContextTests: XCTestCase {
     }
 
     @MainActor
-    func testUpdatePropagation() {
+    func testTransitiveUpdate() {
         struct TestAtom1: StateAtom, Hashable {
             func defaultValue(context: Context) -> Int {
                 0