Atomic RangeReplaceableCollection Storage in Swift

Store.swift

import Foundation

public final class Store<Element>: RangeReplaceableCollection {

    public typealias Index = Int
    public typealias SubSequence = Store<Element>

    public var startIndex: Index { queue.sync { storage.startIndex } }
    public var endIndex: Index { queue.sync { storage.endIndex } }
    public func index(after i: Index) -> Index { queue.sync { storage.index(after: i) } }

    private lazy var queue: DispatchQueue = {
        DispatchQueue(label: "store-\(String(describing: Element.self))", qos: .background, attributes: .concurrent)
    }()

    fileprivate private(set) var storage: [Element]

    public var isEmpty: Bool {
        queue.sync { storage.isEmpty }
    }

    public var count: Int {
        queue.sync { storage.count }
    }

    public var indices: Range<Index> {
        queue.sync { storage.indices }
    }

    public init() {
        storage = []
    }

    public init<S>(_ elements: S) where S: Sequence, Element == S.Element {
        storage = Array<S.Element>(elements)
    }

    public subscript(bounds: Range<Index>) -> SubSequence {
        queue.sync { .init(storage[bounds]) }
    }

    public subscript(bounds: Index) -> Element {
        get {
            queue.sync { storage[bounds] }
        }
        set {
            queue.async(flags: .barrier) { self.storage[bounds] = newValue }
        }
    }

    public func replaceSubrange<C>(_ subrange: Range<Int>, with newElements: C) where C: Collection, Element == C.Element {
        queue.async(flags: .barrier) {
            self.storage.replaceSubrange(subrange, with: newElements)
        }
    }
    
}

extension Store: Codable where Element: Codable { }
extension Store: Equatable where Element: Equatable {
    public static func == (lhs: Store<Element>, rhs: Store<Element>) -> Bool {
        lhs.storage == rhs.storage
    }
}
extension Store: Hashable where Element: Hashable {
    public func hash(into hasher: inout Hasher) {
        hasher.combine(storage)
    }
}

extension Store: CustomReflectable {
    public var customMirror: Mirror {
        Mirror(reflecting: storage)
    }
}