Merge pull request #1 from yonekawa/redesign_api

yonekawa · yonekawa · commit 3e21ffa8ce92 · 2015-08-10T19:55:21.000+09:00
Use Action.Type to Dispatcher.register
diff --git a/DemoApp/TodoAction.swift b/DemoApp/TodoAction.swift
@@ -15,7 +15,7 @@ class TodoAction {
         typealias Payload = [Todo]
         func invoke() {
             let todos = [Todo(title: "List ToDo 1"), Todo(title: "List ToDo 2"), Todo(title: "List ToDo 3")]
-            Dispatcher.dispatch(self, result: Result(value: todos))
+            Dispatcher.dispatch(self.dynamicType, result: Result(value: todos))
         }
     }
 
@@ -30,7 +30,7 @@ class TodoAction {
         }
         
         func invoke() {
-            Dispatcher.dispatch(self, result: Result(value: Todo(title: self.title)))
+            Dispatcher.dispatch(self.dynamicType, result: Result(value: Todo(title: self.title)))
         }
     }
 }
diff --git a/DemoApp/TodoStore.swift b/DemoApp/TodoStore.swift
@@ -28,7 +28,7 @@ class TodoStore : Store {
     }
 
     init() {
-        Dispatcher.register(TodoAction.List()) { (result) -> Void in
+        Dispatcher.register(TodoAction.List.self) { (result) -> Void in
             switch result {
             case .Success(let box):
                 self.todos = box.value
@@ -38,7 +38,7 @@ class TodoStore : Store {
             }
         }
 
-        Dispatcher.register(TodoAction.Create()) { (result) -> Void in
+        Dispatcher.register(TodoAction.Create.self) { (result) -> Void in
             switch result {
             case .Success(let box):
                 self.todos.insert(box.value, atIndex: 0)
diff --git a/README.md b/README.md
@@ -3,7 +3,7 @@
 [![Circle CI](https://img.shields.io/circleci/project/yonekawa/SwiftFlux/master.svg?style=flat)](https://circleci.com/gh/yonekawa/SwiftFlux)
 [![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
 
-SwiftFlux is an implementation of [Facebook's Flux architecure](https://facebook.github.io/flux/) for Swift. 
+SwiftFlux is an implementation of [Facebook's Flux architecure](https://facebook.github.io/flux/) for Swift.
 It provides concept of "one-way data flow" with **type-safe** modules by Swift language.
 
 - Type of an action payload is inferred from the type of its action.
@@ -67,7 +67,7 @@ class TodoStore : Store {
     }
 
     init() {
-        Dispatcher.register(TodoAction.List()) { (result) -> Void in
+        Dispatcher.register(TodoAction.List.self) { (result) -> Void in
             switch result {
             case .Success(let box):
                 self.todo = box.value
diff --git a/SwiftFlux/Action.swift b/SwiftFlux/Action.swift
@@ -11,5 +11,4 @@ import Result
 
 public protocol Action {
     typealias Payload
-    func invoke() -> Void
 }
diff --git a/SwiftFlux/Dispatcher.swift b/SwiftFlux/Dispatcher.swift
@@ -13,91 +13,89 @@ public class Dispatcher {
     private static let instance = Dispatcher()
     private var callbacks: Dictionary<String, AnyObject> = [:]
     private var _isDispatching = false
-    private var lastId = 0
+    private var lastDispatchIdentifier = 0
     private init() {}
 }
 
-// Public interfaces
 extension Dispatcher {
     public var isDispathing: Bool {
         get {
             return self._isDispatching
         }
     }
 
-    public class func dispatch<T: Action>(action: T, result: Result<T.Payload, NSError>) {
+    public class func dispatch<T: Action>(action: T.Type, result: Result<T.Payload, NSError>) {
         instance.dispatch(action, result: result)
     }
 
-    public class func register<T: Action>(action: T, handler: (Result<T.Payload, NSError>) -> Void) -> String {
+    public class func register<T: Action>(action: T.Type, handler: (Result<T.Payload, NSError>) -> Void) -> String {
         return instance.register(action, handler: handler)
     }
 
-    public class func unregister(id: String) {
-        instance.unregister(id)
+    public class func unregister(identifier: String) {
+        instance.unregister(identifier)
     }
 
-    public class func waitFor<T: Action>(ids: Array<String>, action: T, result: Result<T.Payload, NSError>) {
-        instance.waitFor(ids, action: action, result: result)
+    public class func waitFor<T: Action>(identifiers: Array<String>, action: T.Type, result: Result<T.Payload, NSError>) {
+        instance.waitFor(identifiers, action: action, result: result)
     }
 }
 
-// Private implementation
 extension Dispatcher {
-    private func dispatch<T: Action>(action: T, result: Result<T.Payload, NSError>) {
+    private func dispatch<T: Action>(action: T.Type, result: Result<T.Payload, NSError>) {
         objc_sync_enter(self)
         
         self.startDispatching(action)
-        for id in self.callbacks.keys {
-            self.invokeCallback(id, action: action, result: result)
+        for identifier in self.callbacks.keys {
+            self.invokeCallback(identifier, action: action, result: result)
         }
         self.finishDispatching(action)
         
         objc_sync_exit(self)
     }
     
-    private func register<T: Action>(action: T, handler: (Result<T.Payload, NSError>) -> Void) -> String {
-        let nextId = "DISPATCH_CALLBACK_\(++self.lastId)"
-        self.callbacks[nextId] = DispatchCallback<T>(action: action, handler: handler)
-        return nextId
+    private func register<T: Action>(action: T.Type, handler: (Result<T.Payload, NSError>) -> Void) -> String {
+        let nextDispatchIdentifier = "DISPATCH_CALLBACK_\(++self.lastDispatchIdentifier)"
+        self.callbacks[nextDispatchIdentifier] = DispatchCallback<T>(action: action, handler: handler)
+        return nextDispatchIdentifier
     }
 
-    private func unregister(id: String) {
-        self.callbacks.removeValueForKey(id)
+    private func unregister(identifier: String) {
+        self.callbacks.removeValueForKey(identifier)
     }
     
-    private func waitFor<T: Action>(ids: Array<String>, action: T, result: Result<T.Payload, NSError>) {
-        for id in ids {
-            if let callback = self.callbacks[id] as? DispatchCallback<T> {
+    private func waitFor<T: Action>(identifiers: Array<String>, action: T.Type, result: Result<T.Payload, NSError>) {
+        for identifier in identifiers {
+            if let callback = self.callbacks[identifier] as? DispatchCallback<T> {
                 switch callback.status {
                 case .Handled:
                     continue
                 case .Pending:
                     // Circular dependency detected while
                     continue
                 default:
-                    self.invokeCallback(id, action: action, result: result)
+                    self.invokeCallback(identifier, action: action, result: result)
                 }
             }
         }
     }
     
-    private func startDispatching<T: Action>(action: T) {
+    private func startDispatching<T: Action>(action: T.Type) {
         self._isDispatching = true
         
-        for (id, calllback) in self.callbacks {
-            if let callback = self.callbacks[id] as? DispatchCallback<T> {
+        for (identifier, calllback) in self.callbacks {
+            if let callback = self.callbacks[identifier] as? DispatchCallback<T> {
                 callback.status = DispatchStatus.Waiting
             }
         }
     }
     
-    private func finishDispatching<T: Action>(action: T) {
+    private func finishDispatching<T: Action>(action: T.Type) {
         self._isDispatching = false
     }
     
-    private func invokeCallback<T: Action>(id: String, action: T, result: Result<T.Payload, NSError>) {
-        if let callback = self.callbacks[id] as? DispatchCallback<T> {
+    private func invokeCallback<T: Action>(identifier: String, action: T.Type, result: Result<T.Payload, NSError>) {
+        if let callback = self.callbacks[identifier] as? DispatchCallback<T> {
             callback.status = DispatchStatus.Pending
             callback.handler(result)
             callback.status = DispatchStatus.Handled
@@ -106,12 +104,12 @@ extension Dispatcher {
 }
 
 internal class DispatchCallback<T: Action> {
-    let action: T
+    let action: T.Type
     let handler: (Result<T.Payload, NSError>) -> Void
     
     var status: DispatchStatus = DispatchStatus.Waiting
     
-    init(action: T, handler: (Result<T.Payload, NSError>) -> Void) {
+    init(action: T.Type, handler: (Result<T.Payload, NSError>) -> Void) {
         self.action = action
         self.handler = handler
     }
diff --git a/SwiftFlux/EventEmitter.swift b/SwiftFlux/EventEmitter.swift
@@ -11,31 +11,31 @@ import Foundation
 public class EventEmitter {
     private static let instance = EventEmitter()
     private var listenes: Dictionary<String, AnyObject> = [:]
-    private var lastId = 0
+    private var lastListenerIdentifier = 0
     private init() {}
 }
 
 extension EventEmitter {
     public class func listen<T: Store>(store: T, event: T.Event, handler: () -> Void) -> String {
         return self.instance.listen(store, event: event, handler: handler)
     }
-    
+
     public class func emit<T: Store>(store: T, event: T.Event) {
         self.instance.emit(store, event: event)
     }
-    
-    public class func unlisten(id: String) {
-        self.instance.unlisten(id)
+
+    public class func unlisten(identifier: String) {
+        self.instance.unlisten(identifier)
     }
 }
 
 extension EventEmitter {
     private func listen<T: Store>(store: T, event: T.Event, handler: () -> Void) -> String {
-        let nextId = "EVENT_LISTENER_\(++lastId)"
-        self.listenes[nextId] = EventListener<T>(store: store, event: event, handler: handler)
-        return nextId
+        let nextListenerIdentifier = "EVENT_LISTENER_\(++lastListenerIdentifier)"
+        self.listenes[nextListenerIdentifier] = EventListener<T>(store: store, event: event, handler: handler)
+        return nextListenerIdentifier
     }
-    
+
     private func emit<T: Store>(store: T, event: T.Event) {
         for (key, value) in self.listenes {
             if let listener = value as? EventListener<T> {
@@ -45,9 +45,9 @@ extension EventEmitter {
             }
         }
     }
-    
-    private func unlisten(id: String) {
-        self.listenes.removeValueForKey(id)
+
+    private func unlisten(identifier: String) {
+        self.listenes.removeValueForKey(identifier)
     }
 }
 
diff --git a/SwiftFlux/Info.plist b/SwiftFlux/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.0.1</string>
+	<string>0.0.2</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
diff --git a/SwiftFlux/Store.swift b/SwiftFlux/Store.swift
@@ -9,5 +9,5 @@
 import Foundation
 
 public protocol Store {
-    typealias Event: Hashable
+    typealias Event: Equatable
 }
diff --git a/SwiftFluxTests/DispatcherSpec.swift b/SwiftFluxTests/DispatcherSpec.swift
@@ -33,15 +33,15 @@ class DispatcherSpec: QuickSpec {
                 fails = []
                 callbacks = []
 
-                let id1 = Dispatcher.register(TestAction()) { (result) in
+                let id1 = Dispatcher.register(TestAction.self) { (result) in
                     switch result {
                     case .Success(let box):
                         results.append("\(box.value.name)1")
                     case .Failure(let box):
                         fails.append("fail")
                     }
                 }
-                let id2 = Dispatcher.register(TestAction()) { (result) in
+                let id2 = Dispatcher.register(TestAction.self) { (result) in
                     switch result {
                     case .Success(let box):
                         results.append("\(box.value.name)2")
@@ -61,7 +61,7 @@ class DispatcherSpec: QuickSpec {
             
             context("when action succeeded") {
                 it("should dispatch to registered callback handlers") {
-                    Dispatcher.dispatch(TestAction(), result: Result(value: TestModel(name: "test")))
+                    Dispatcher.dispatch(TestAction.self, result: Result(value: TestModel(name: "test")))
                     expect(results.count).to(equal(2))
                     expect(fails.isEmpty).to(beTruthy())
                     expect(results).to(contain("test1", "test2"))
@@ -70,7 +70,7 @@ class DispatcherSpec: QuickSpec {
             
             context("when action failed") {
                 it("should dispatch to registered callback handlers") {
-                    Dispatcher.dispatch(TestAction(), result: Result(error: NSError()))
+                    Dispatcher.dispatch(TestAction.self, result: Result(error: NSError()))
                     expect(fails.count).to(equal(2))
                     expect(results.isEmpty).to(beTruthy())
                 }
diff --git a/SwiftFluxTests/Info.plist b/SwiftFluxTests/Info.plist
@@ -15,10 +15,10 @@
 	<key>CFBundlePackageType</key>
 	<string>BNDL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0</string>
+	<string>0.0.2</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
-	<string>1</string>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
 </dict>
 </plist>

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ class TodoAction {`
`15`	`15`	`typealias Payload = [Todo]`
`16`	`16`	`func invoke() {`
`17`	`17`	`let todos = [Todo(title: "List ToDo 1"), Todo(title: "List ToDo 2"), Todo(title: "List ToDo 3")]`
`18`		`- Dispatcher.dispatch(self, result: Result(value: todos))`
	`18`	`+ Dispatcher.dispatch(self.dynamicType, result: Result(value: todos))`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`@@ -30,7 +30,7 @@ class TodoAction {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`func invoke() {`
`33`		`- Dispatcher.dispatch(self, result: Result(value: Todo(title: self.title)))`
	`33`	`+ Dispatcher.dispatch(self.dynamicType, result: Result(value: Todo(title: self.title)))`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ class TodoStore : Store {`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`init() {`
`31`		`- Dispatcher.register(TodoAction.List()) { (result) -> Void in`
	`31`	`+ Dispatcher.register(TodoAction.List.self) { (result) -> Void in`
`32`	`32`	`switch result {`
`33`	`33`	`case .Success(let box):`
`34`	`34`	`self.todos = box.value`
`@@ -38,7 +38,7 @@ class TodoStore : Store {`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`		`- Dispatcher.register(TodoAction.Create()) { (result) -> Void in`
	`41`	`+ Dispatcher.register(TodoAction.Create.self) { (result) -> Void in`
`42`	`42`	`switch result {`
`43`	`43`	`case .Success(let box):`
`44`	`44`	`self.todos.insert(box.value, atIndex: 0)`
Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,4 @@ import Result`
`11`	`11`
`12`	`12`	`public protocol Action {`
`13`	`13`	`typealias Payload`
`14`		`- func invoke() -> Void`
`15`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,91 +13,89 @@ public class Dispatcher {`
`13`	`13`	`private static let instance = Dispatcher()`
`14`	`14`	`private var callbacks: Dictionary<String, AnyObject> = [:]`
`15`	`15`	`private var _isDispatching = false`
`16`		`- private var lastId = 0`
	`16`	`+ private var lastDispatchIdentifier = 0`
`17`	`17`	`private init() {}`
`18`	`18`	`}`
`19`	`19`
`20`		`-// Public interfaces`
`21`	`20`	`extension Dispatcher {`
`22`	`21`	`public var isDispathing: Bool {`
`23`	`22`	`get {`
`24`	`23`	`return self._isDispatching`
`25`	`24`	`}`
`26`	`25`	`}`
`27`	`26`
`28`		`- public class func dispatch<T: Action>(action: T, result: Result<T.Payload, NSError>) {`
	`27`	`+ public class func dispatch<T: Action>(action: T.Type, result: Result<T.Payload, NSError>) {`
`29`	`28`	`instance.dispatch(action, result: result)`
`30`	`29`	`}`
`31`	`30`
`32`		`- public class func register<T: Action>(action: T, handler: (Result<T.Payload, NSError>) -> Void) -> String {`
	`31`	`+ public class func register<T: Action>(action: T.Type, handler: (Result<T.Payload, NSError>) -> Void) -> String {`
`33`	`32`	`return instance.register(action, handler: handler)`
`34`	`33`	`}`
`35`	`34`
`36`		`- public class func unregister(id: String) {`
`37`		`- instance.unregister(id)`
	`35`	`+ public class func unregister(identifier: String) {`
	`36`	`+ instance.unregister(identifier)`
`38`	`37`	`}`
`39`	`38`
`40`		`- public class func waitFor<T: Action>(ids: Array<String>, action: T, result: Result<T.Payload, NSError>) {`
`41`		`- instance.waitFor(ids, action: action, result: result)`
	`39`	`+ public class func waitFor<T: Action>(identifiers: Array<String>, action: T.Type, result: Result<T.Payload, NSError>) {`
	`40`	`+ instance.waitFor(identifiers, action: action, result: result)`
`42`	`41`	`}`
`43`	`42`	`}`
`44`	`43`
`45`		`-// Private implementation`
`46`	`44`	`extension Dispatcher {`
`47`		`- private func dispatch<T: Action>(action: T, result: Result<T.Payload, NSError>) {`
	`45`	`+ private func dispatch<T: Action>(action: T.Type, result: Result<T.Payload, NSError>) {`
`48`	`46`	`objc_sync_enter(self)`
`49`	`47`
`50`	`48`	`self.startDispatching(action)`
`51`		`- for id in self.callbacks.keys {`
`52`		`- self.invokeCallback(id, action: action, result: result)`
	`49`	`+ for identifier in self.callbacks.keys {`
	`50`	`+ self.invokeCallback(identifier, action: action, result: result)`
`53`	`51`	`}`
`54`	`52`	`self.finishDispatching(action)`
`55`	`53`
`56`	`54`	`objc_sync_exit(self)`
`57`	`55`	`}`
`58`	`56`
`59`		`- private func register<T: Action>(action: T, handler: (Result<T.Payload, NSError>) -> Void) -> String {`
`60`		`- let nextId = "DISPATCH_CALLBACK_\(++self.lastId)"`
`61`		`- self.callbacks[nextId] = DispatchCallback<T>(action: action, handler: handler)`
`62`		`- return nextId`
	`57`	`+ private func register<T: Action>(action: T.Type, handler: (Result<T.Payload, NSError>) -> Void) -> String {`
	`58`	`+ let nextDispatchIdentifier = "DISPATCH_CALLBACK_\(++self.lastDispatchIdentifier)"`
	`59`	`+ self.callbacks[nextDispatchIdentifier] = DispatchCallback<T>(action: action, handler: handler)`
	`60`	`+ return nextDispatchIdentifier`
`63`	`61`	`}`
`64`	`62`
`65`		`- private func unregister(id: String) {`
`66`		`- self.callbacks.removeValueForKey(id)`
	`63`	`+ private func unregister(identifier: String) {`
	`64`	`+ self.callbacks.removeValueForKey(identifier)`
`67`	`65`	`}`
`68`	`66`
`69`		`- private func waitFor<T: Action>(ids: Array<String>, action: T, result: Result<T.Payload, NSError>) {`
`70`		`- for id in ids {`
`71`		`- if let callback = self.callbacks[id] as? DispatchCallback<T> {`
	`67`	`+ private func waitFor<T: Action>(identifiers: Array<String>, action: T.Type, result: Result<T.Payload, NSError>) {`
	`68`	`+ for identifier in identifiers {`
	`69`	`+ if let callback = self.callbacks[identifier] as? DispatchCallback<T> {`
`72`	`70`	`switch callback.status {`
`73`	`71`	`case .Handled:`
`74`	`72`	`continue`
`75`	`73`	`case .Pending:`
`76`	`74`	`// Circular dependency detected while`
`77`	`75`	`continue`
`78`	`76`	`default:`
`79`		`- self.invokeCallback(id, action: action, result: result)`
	`77`	`+ self.invokeCallback(identifier, action: action, result: result)`
`80`	`78`	`}`
`81`	`79`	`}`
`82`	`80`	`}`
`83`	`81`	`}`
`84`	`82`
`85`		`- private func startDispatching<T: Action>(action: T) {`
	`83`	`+ private func startDispatching<T: Action>(action: T.Type) {`
`86`	`84`	`self._isDispatching = true`
`87`	`85`
`88`		`- for (id, calllback) in self.callbacks {`
`89`		`- if let callback = self.callbacks[id] as? DispatchCallback<T> {`
	`86`	`+ for (identifier, calllback) in self.callbacks {`
	`87`	`+ if let callback = self.callbacks[identifier] as? DispatchCallback<T> {`
`90`	`88`	`callback.status = DispatchStatus.Waiting`
`91`	`89`	`}`
`92`	`90`	`}`
`93`	`91`	`}`
`94`	`92`
`95`		`- private func finishDispatching<T: Action>(action: T) {`
	`93`	`+ private func finishDispatching<T: Action>(action: T.Type) {`
`96`	`94`	`self._isDispatching = false`
`97`	`95`	`}`
`98`	`96`
`99`		`- private func invokeCallback<T: Action>(id: String, action: T, result: Result<T.Payload, NSError>) {`
`100`		`- if let callback = self.callbacks[id] as? DispatchCallback<T> {`
	`97`	`+ private func invokeCallback<T: Action>(identifier: String, action: T.Type, result: Result<T.Payload, NSError>) {`
	`98`	`+ if let callback = self.callbacks[identifier] as? DispatchCallback<T> {`
`101`	`99`	`callback.status = DispatchStatus.Pending`
`102`	`100`	`callback.handler(result)`
`103`	`101`	`callback.status = DispatchStatus.Handled`
`@@ -106,12 +104,12 @@ extension Dispatcher {`
`106`	`104`	`}`
`107`	`105`
`108`	`106`	`internal class DispatchCallback<T: Action> {`
`109`		`- let action: T`
	`107`	`+ let action: T.Type`
`110`	`108`	`let handler: (Result<T.Payload, NSError>) -> Void`
`111`	`109`
`112`	`110`	`var status: DispatchStatus = DispatchStatus.Waiting`
`113`	`111`
`114`		`- init(action: T, handler: (Result<T.Payload, NSError>) -> Void) {`
	`112`	`+ init(action: T.Type, handler: (Result<T.Payload, NSError>) -> Void) {`
`115`	`113`	`self.action = action`
`116`	`114`	`self.handler = handler`
`117`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,31 +11,31 @@ import Foundation`
`11`	`11`	`public class EventEmitter {`
`12`	`12`	`private static let instance = EventEmitter()`
`13`	`13`	`private var listenes: Dictionary<String, AnyObject> = [:]`
`14`		`- private var lastId = 0`
	`14`	`+ private var lastListenerIdentifier = 0`
`15`	`15`	`private init() {}`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`extension EventEmitter {`
`19`	`19`	`public class func listen<T: Store>(store: T, event: T.Event, handler: () -> Void) -> String {`
`20`	`20`	`return self.instance.listen(store, event: event, handler: handler)`
`21`	`21`	`}`
`22`		`-`
	`22`	`+`
`23`	`23`	`public class func emit<T: Store>(store: T, event: T.Event) {`
`24`	`24`	`self.instance.emit(store, event: event)`
`25`	`25`	`}`
`26`		`-`
`27`		`- public class func unlisten(id: String) {`
`28`		`- self.instance.unlisten(id)`
	`26`	`+`
	`27`	`+ public class func unlisten(identifier: String) {`
	`28`	`+ self.instance.unlisten(identifier)`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`extension EventEmitter {`
`33`	`33`	`private func listen<T: Store>(store: T, event: T.Event, handler: () -> Void) -> String {`
`34`		`- let nextId = "EVENT_LISTENER_\(++lastId)"`
`35`		`- self.listenes[nextId] = EventListener<T>(store: store, event: event, handler: handler)`
`36`		`- return nextId`
	`34`	`+ let nextListenerIdentifier = "EVENT_LISTENER_\(++lastListenerIdentifier)"`
	`35`	`+ self.listenes[nextListenerIdentifier] = EventListener<T>(store: store, event: event, handler: handler)`
	`36`	`+ return nextListenerIdentifier`
`37`	`37`	`}`
`38`		`-`
	`38`	`+`
`39`	`39`	`private func emit<T: Store>(store: T, event: T.Event) {`
`40`	`40`	`for (key, value) in self.listenes {`
`41`	`41`	`if let listener = value as? EventListener<T> {`
`@@ -45,9 +45,9 @@ extension EventEmitter {`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`	`}`
`48`		`-`
`49`		`- private func unlisten(id: String) {`
`50`		`- self.listenes.removeValueForKey(id)`
	`48`	`+`
	`49`	`+ private func unlisten(identifier: String) {`
	`50`	`+ self.listenes.removeValueForKey(identifier)`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@`
`9`	`9`	`import Foundation`
`10`	`10`
`11`	`11`	`public protocol Store {`
`12`		`- typealias Event: Hashable`
	`12`	`+ typealias Event: Equatable`
`13`	`13`	`}`