         }
     }
     
-    func subscribe(store: Store<State>, executer: Executer) -> Disposable {
+    func subscribe(store: Store<State>, executer: Executer) -> Key {
         return buffer.modify { buffer in
             let key = buffer.nextKey
             buffer.nextKey = key.next
             
-            let disposable = Disposable { [weak self] in
-                self?.unsubscribe(for: key)
-            }
-            
             let observer: (State.Action) -> Void = { [weak store] action in
-                executer.execute {
-                    guard !disposable.isDisposed else { return }
-                    store?.dispatch(action: action)
-                }
+                executer.execute { store?.dispatch(action: action) }
             }
             
             buffer.subscriptions.append((key: key, observer: observer))
-            return disposable
-        }
-    }
-    
-    @inline(__always)
-    private func unsubscribe(for key: Key) {
+            return key
+        }
+    }
+    
+    func unsubscribe(for key: Key) {
         buffer.modify { buffer in
             for index in buffer.subscriptions.startIndex..<buffer.subscriptions.endIndex where buffer.subscriptions[index].key == key {
                 buffer.subscriptions.remove(at: index)

    private let state: State
    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)

        
        static func == (lhs: Key, rhs: Key) -> Bool {
            return lhs.value == rhs.value
        }
    }
}
