Atomic Property Wrapper Using Unfair Lock

AtomicPropertyWrapper.swift

// MARK: - Atomic
@propertyWrapper struct Atomic<T> {
    private let lock = UnfairLock()
    
    private var value: T
    
    var wrappedValue: T {
        get {
            lock.lock()
            defer {
                lock.unlock()
            }
            return value
        }
        mutating set {
            lock.lock()
            defer {
                lock.unlock()
            }
            value = newValue
        }
    }
    
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
    
    mutating func adjust(block: @escaping ( _ value: T) -> T) {
        lock.lock()
        defer {
            lock.unlock()
        }
        value = block(value)
    }
}
// MARK: - Atomic.Bool
extension Atomic where T == Bool {
    mutating func toggle() {
        adjust { $0.toggle() }
    }
}

//@Atomic var value = false
//_value.toggle()