 
 private extension Dispatcher.Disposable {
     final class Scope {
-        private var disposables = Atomic(ContiguousArray<Dispatcher.Disposable>())
+        private var disposables = ContiguousArray<Dispatcher.Disposable>()
         
         static func += (scope: Dispatcher.Disposable.Scope, disposable: Dispatcher.Disposable) {
-            scope.disposables.modify { $0.append(disposable) }
-        }
-        
-        deinit {
-            disposables.synchronized { disposables in
-                for disposable in disposables {
-                    disposable.dispose()
-                }
-            }
-        }
-    }
-}
-
-private final class DispatcherContext {
+            scope.disposables.append(disposable)
+        }
+        
+        deinit {
+            for disposable in disposables {
+                disposable.dispose()
+            }
+        }
+    }
+}
+
+private struct DispatcherContext {
     static let shared = DispatcherContext()
     
     private var dispatchers = Atomic([Identifier: Any]())

                }
            }
            
            buffer.entries.append((key: key, observer: observer))
            return disposable
        }
    }

}

private final class Dispatcher<State: VueFlux.State> {
    private typealias Subscription = (key: Key, observer: (State.Action) -> Void)
    private typealias Buffer = (nextKey: Key, subscriptions: ContiguousArray<Subscription>)
    
    static var shared: Dispatcher<State> {
        return DispatcherContext.shared.dispatcher(for: State.self)
    }
    
    private let buffer = Atomic<Buffer>((nextKey: Key.first, subscriptions: []))
    
    init() {}
    
    func dispatch(action: State.Action) {
        buffer.synchronized { buffer in
            for entry in buffer.subscriptions {
                entry.observer(action)
            }
        }
