     struct Key: Equatable {
         private let value: UInt64
         
-        fileprivate static var first: Key {
+        static var first: Key {
             return .init(value: 0)
         }
         
-        fileprivate var next: Key {
+        var next: Key {
             return .init(value: value &+ 1)
+        }
+        
+        private init(value: UInt64) {
+            self.value = value
         }
         
         static func == (lhs: Key, rhs: Key) -> Bool {


public struct Executer {
    public static var immediate: Executer {
        return .init { action in
            action()
        }
    }
    
    public static var mainThread: Executer {
        let innerExecuter = MainThreadInnerExecuter()
        return .init { action in
            innerExecuter.execute(action)
        }
    }
    
    public static func queue(_ dispatchQueue: DispatchQueue) -> Executer {
        return .init { action in
            dispatchQueue.async(execute: action)
        }
    }
    

    private let mutations: State.Mutations
    private let dispatcher = Dispatcher<State>()
    private let disposableScope = Dispatcher<State>.Disposable.Scope()
    
    public static var actions: Actions<State> {
        return .init(dispatcher: Dispatcher<State>.shared)
    }
