Add asynchronous effect handling routes

Author: kmcbride

MobiusCore/Source/EffectHandlers/EffectExecutor.swift

@@ -16,6 +16,7 @@ import Foundation
 
 final class EffectExecutor<Effect, Event>: Connectable {
     private let handleEffect: (Effect, EffectCallback<Event>) -> Disposable
+    private let outputQueue: DispatchQueue?
     private var output: Consumer<Event>?
 
     private let lock = Lock()
@@ -26,8 +27,9 @@ final class EffectExecutor<Effect, Event>: Connectable {
     private var handlingEffects: [Int64: EffectHandlingState<Event>] = [:]
     private var nextID = Int64(0)
 
-    init(handleInput: @escaping (Effect, EffectCallback<Event>) -> Disposable) {
+    init(handleInput: @escaping (Effect, EffectCallback<Event>) -> Disposable, outputQueue: DispatchQueue? = nil) {
         self.handleEffect = handleInput
+        self.outputQueue = outputQueue
     }
 
     func connect(_ consumer: @escaping Consumer<Event>) -> Connection<Effect> {
@@ -58,7 +60,13 @@ final class EffectExecutor<Effect, Event>: Connectable {
         let callback = EffectCallback(
             // Any events produced as a result of handling the effect will be sent to this class's `output` consumer,
             // unless it has already been disposed.
-            onSend: { [weak self] event in self?.output?(event) },
+            onSend: { [weak self] event in
+                if let outputQueue = self?.outputQueue {
+                    outputQueue.async { self?.output?(event) }
+                } else {
+                    self?.output?(event)
+                }
+            },
             // Once an effect has been handled, remove the reference to its callback and disposable.
             onEnd: { [weak self] in self?.delete(id: id) }
         )

MobiusCore/Source/EffectHandlers/EffectRouter.swift

@@ -59,7 +59,7 @@ public struct EffectRouter<Effect, Event> {
     public func routeEffects<EffectParameters>(
         withParameters extractParameters: @escaping (Effect) -> EffectParameters?
     ) -> _PartialEffectRouter<Effect, EffectParameters, Event> {
-        return _PartialEffectRouter(routes: routes, path: extractParameters, queue: nil)
+        return _PartialEffectRouter(routes: routes, path: extractParameters, queue: nil, receiveQueue: nil)
     }
 
     /// Convert this `EffectRouter` into `Connectable` which can be attached to a Mobius Loop, or called on its own to
@@ -77,14 +77,15 @@ public struct _PartialEffectRouter<Effect, EffectParameters, Event> {
     fileprivate let routes: [Route<Effect, Event>]
     fileprivate let path: (Effect) -> EffectParameters?
     fileprivate let queue: DispatchQueue?
+    fileprivate let receiveQueue: DispatchQueue?
 
     /// Route to an `EffectHandler`.
     ///
     /// - Parameter effectHandler: the `EffectHandler` for the route in question.
     public func to<Handler: EffectHandler>(
         _ effectHandler: Handler
     ) -> EffectRouter<Effect, Event> where Handler.EffectParameters == EffectParameters, Handler.Event == Event {
-        let connectable = EffectExecutor(handleInput: effectHandler.handle)
+        let connectable = EffectExecutor(handleInput: effectHandler.handle, outputQueue: receiveQueue)
         let route = Route<Effect, Event>(extractParameters: path, connectable: connectable, queue: queue)
         return EffectRouter(routes: routes + [route])
     }
@@ -100,7 +101,7 @@ public struct _PartialEffectRouter<Effect, EffectParameters, Event> {
         return EffectRouter(routes: routes + [route])
     }
 
-    /// Handle an the current `Effect` asynchronously on the provided `DispatchQueue`
+    /// Handle the current `Effect` asynchronously on the provided `DispatchQueue`
     ///
     /// Warning: Dispatching events to a loop from a different queue is not a thread-safe operation and will require
     /// manual synchronization unless the loop is run in a `MobiusController`.
@@ -109,7 +110,14 @@ public struct _PartialEffectRouter<Effect, EffectParameters, Event> {
     ///
     /// - Parameter queue: The `DispatchQueue` that the current `Effect` should be handled on.
     public func on(queue: DispatchQueue) -> Self {
-        return Self(routes: routes, path: path, queue: queue)
+        return Self(routes: routes, path: path, queue: queue, receiveQueue: receiveQueue)
+    }
+
+    /// Receive an `Event` asynchronously on the provided `DispatchQueue`
+    ///
+    /// - Parameter queue: The `DispatchQueue` that any `Event` should be received on.
+    public func receiveOn(queue receiveQueue: DispatchQueue) -> Self {
+        return Self(routes: routes, path: path, queue: queue, receiveQueue: receiveQueue)
     }
 }