Format

Author: ra1028

Sources/Atoms/Core/SubscriberState.swift

@@ -4,45 +4,45 @@ import Foundation
 internal final class SubscriberState {
     let token = SubscriberKey.Token()
 
-#if compiler(>=6)
-    nonisolated(unsafe) var subscribing = Set<AtomKey>()
-    nonisolated(unsafe) var unsubscribe: ((Set<AtomKey>) -> Void)?
+    #if compiler(>=6)
+        nonisolated(unsafe) var subscribing = Set<AtomKey>()
+        nonisolated(unsafe) var unsubscribe: ((Set<AtomKey>) -> Void)?
 
-    // TODO: Use isolated synchronous deinit once it's available.
-    // 0371-isolated-synchronous-deinit
-    deinit {
-        if Thread.isMainThread {
-            unsubscribe?(subscribing)
-        }
-        else {
-            Task { @MainActor [unsubscribe, subscribing] in
+        // TODO: Use isolated synchronous deinit once it's available.
+        // 0371-isolated-synchronous-deinit
+        deinit {
+            if Thread.isMainThread {
                 unsubscribe?(subscribing)
             }
+            else {
+                Task { @MainActor [unsubscribe, subscribing] in
+                    unsubscribe?(subscribing)
+                }
+            }
         }
-    }
-#else
-    private var _subscribing = UnsafeUncheckedSendable(Set<AtomKey>())
-    private var _unsubscribe = UnsafeUncheckedSendable<((Set<AtomKey>) -> Void)?>(nil)
-
-    var subscribing: Set<AtomKey> {
-        _read { yield _subscribing.value }
-        _modify { yield &_subscribing.value }
-    }
+    #else
+        private var _subscribing = UnsafeUncheckedSendable(Set<AtomKey>())
+        private var _unsubscribe = UnsafeUncheckedSendable<((Set<AtomKey>) -> Void)?>(nil)
 
-    var unsubscribe: ((Set<AtomKey>) -> Void)? {
-        _read { yield _unsubscribe.value }
-        _modify { yield &_unsubscribe.value }
-    }
+        var subscribing: Set<AtomKey> {
+            _read { yield _subscribing.value }
+            _modify { yield &_subscribing.value }
+        }
 
-    deinit {
-        if Thread.isMainThread {
-            _unsubscribe.value?(_subscribing.value)
+        var unsubscribe: ((Set<AtomKey>) -> Void)? {
+            _read { yield _unsubscribe.value }
+            _modify { yield &_unsubscribe.value }
         }
-        else {
-            Task { @MainActor [_unsubscribe, _subscribing] in
+
+        deinit {
+            if Thread.isMainThread {
                 _unsubscribe.value?(_subscribing.value)
             }
+            else {
+                Task { @MainActor [_unsubscribe, _subscribing] in
+                    _unsubscribe.value?(_subscribing.value)
+                }
+            }
         }
-    }
-#endif
+    #endif
 }

Sources/Atoms/Modifier/ChangesOfModifier.swift

@@ -22,19 +22,19 @@ public extension Atom {
     /// - Parameter keyPath: A key path for the property of the original atom value.
     ///
     /// - Returns: An atom that provides the partial property of the original atom value.
-#if hasFeature(InferSendableFromCaptures)
-    func changes<T: Equatable>(
-        of keyPath: KeyPath<Produced, T> & Sendable
-    ) -> ModifiedAtom<Self, ChangesOfModifier<Produced, T>> {
-        modifier(ChangesOfModifier(keyPath: keyPath))
-    }
-#else
-    func changes<T: Equatable>(
-        of keyPath: KeyPath<Produced, T>
-    ) -> ModifiedAtom<Self, ChangesOfModifier<Produced, T>> {
-        modifier(ChangesOfModifier(keyPath: keyPath))
-    }
-#endif
+    #if hasFeature(InferSendableFromCaptures)
+        func changes<T: Equatable>(
+            of keyPath: KeyPath<Produced, T> & Sendable
+        ) -> ModifiedAtom<Self, ChangesOfModifier<Produced, T>> {
+            modifier(ChangesOfModifier(keyPath: keyPath))
+        }
+    #else
+        func changes<T: Equatable>(
+            of keyPath: KeyPath<Produced, T>
+        ) -> ModifiedAtom<Self, ChangesOfModifier<Produced, T>> {
+            modifier(ChangesOfModifier(keyPath: keyPath))
+        }
+    #endif
 }
 
 /// A modifier that derives a partial property with the specified key path from the original atom
@@ -57,22 +57,22 @@ public struct ChangesOfModifier<Base, Produced: Equatable>: AtomModifier {
         }
     }
 
-#if hasFeature(InferSendableFromCaptures)
-    private let keyPath: KeyPath<Base, Produced> & Sendable
+    #if hasFeature(InferSendableFromCaptures)
+        private let keyPath: KeyPath<Base, Produced> & Sendable
 
-    internal init(keyPath: KeyPath<Base, Produced> & Sendable) {
-        self.keyPath = keyPath
-    }
-#else
-    private let _keyPath: UnsafeUncheckedSendable<KeyPath<Base, Produced>>
-    private var keyPath: KeyPath<Base, Produced> {
-        _keyPath.value
-    }
+        internal init(keyPath: KeyPath<Base, Produced> & Sendable) {
+            self.keyPath = keyPath
+        }
+    #else
+        private let _keyPath: UnsafeUncheckedSendable<KeyPath<Base, Produced>>
+        private var keyPath: KeyPath<Base, Produced> {
+            _keyPath.value
+        }
 
-    internal init(keyPath: KeyPath<Base, Produced>) {
-        _keyPath = UnsafeUncheckedSendable(keyPath)
-    }
-#endif
+        internal init(keyPath: KeyPath<Base, Produced>) {
+            _keyPath = UnsafeUncheckedSendable(keyPath)
+        }
+    #endif
 
     /// A unique value used to identify the modifier internally.
     public var key: Key {