Merge pull request #153 from JensAyton/fix-logging-adapators

Fix and simplify logging adaptors

Author: JensAyton

MobiusCore/Source/LoggingAdaptors.swift

@@ -17,51 +17,55 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/// Helper to wrap initator functions with log calls.
-///
-/// Also adds call stack annotation where we call into the client-provided initiator.
-final class LoggingInitiate<Model, Effect> {
-    typealias Initiate = MobiusCore.Initiate<Model, Effect>
-    typealias First = MobiusCore.First<Model, Effect>
-
-    private let realInit: Initiate
-    private let willInit: (Model) -> Void
-    private let didInit: (Model, First) -> Void
+typealias UpdateClosure<Model, Event, Effect> = (Model, Event) -> Next<Model, Effect>
 
-    init<Logger: MobiusLogger>(_ realInit: @escaping Initiate, logger: Logger)
-    where Logger.Model == Model, Logger.Effect == Effect {
-        self.realInit = realInit
-        willInit = logger.willInitiate
-        didInit = logger.didInitiate
+extension MobiusLogger {
+    /// Wraps an Initiate in logging calls and stack annotations
+    func wrap(initiate: @escaping Initiate<Model, Effect>) -> Initiate<Model, Effect> {
+        return { model in
+            self.willInitiate(model: model)
+            let result = invokeInitiate(initiate, model: model)
+            self.didInitiate(model: model, first: result)
+            return result
+        }
     }
 
-    func initiate(_ model: Model) -> First {
-        willInit(model)
-        let result = invokeInitiate(model: model)
-        didInit(model, result)
-
-        return result
+    /// Wraps an update closure in logging calls and stack annotations
+    func wrap(update: @escaping UpdateClosure<Model, Event, Effect>) -> UpdateClosure<Model, Event, Effect> {
+        return { model, event in
+            self.willUpdate(model: model, event: event)
+            let result = invokeUpdate(update, model: model, event: event)
+            self.didUpdate(model: model, event: event, next: result)
+            return result
+        }
     }
 
-    @inline(never)
-    @_silgen_name("__MOBIUS_IS_CALLING_AN_INITIATOR_FUNCTION__")
-    private func invokeInitiate(model: Model) -> First {
-        return realInit(model)
+    /// Wraps an Update in logging calls and stack annotations
+    func wrap(update: Update<Model, Event, Effect>) -> Update<Model, Event, Effect> {
+        return Update(wrap(update: update.updateClosure))
     }
 }
 
-extension Update {
-    /// Helper to wrap update functions with log calls.
-    ///
-    /// Also adds call stack annotation where we call into the client-provided update.
-    @inline(never)
-    @_silgen_name("__MOBIUS_IS_CALLING_AN_UPDATE_FUNCTION__")
-    func logging<L: MobiusLogger>(_ logger: L) -> Update where L.Model == Model, L.Event == Event, L.Effect == Effect {
-        return Update { model, event in
-            logger.willUpdate(model: model, event: event)
-            let next = self.update(model: model, event: event)
-            logger.didUpdate(model: model, event: event, next: next)
-            return next
-        }
-    }
+/// Invoke an initiate function, leaving a hint on the stack.
+///
+/// To work as intended, this function must be exactly like this. `@_silgen_name` can’t be used on a closure,
+/// for example.
+@inline(never)
+@_silgen_name("__MOBIUS_IS_CALLING_AN_INITIATOR_FUNCTION__")
+private func invokeInitiate<Model, Effect>(_ initiate: Initiate<Model, Effect>, model: Model) -> First<Model, Effect> {
+    return initiate(model)
+}
+
+/// Invoke an update function, leaving a hint on the stack.
+///
+/// To work as intended, this function must be exactly like this. `@_silgen_name` can’t be used on a closure,
+/// for example.
+@inline(never)
+@_silgen_name("__MOBIUS_IS_CALLING_AN_UPDATE_FUNCTION__")
+private func invokeUpdate<Model, Event, Effect>(
+    _ update: @escaping (Model, Event) -> Next<Model, Effect>,
+    model: Model,
+    event: Event
+) -> Next<Model, Effect> {
+    return update(model, event)
 }

MobiusCore/Source/Mobius.swift

@@ -34,16 +34,17 @@ import Foundation
 ///
 /// [update function]: https://github.com/spotify/Mobius.swift/wiki/Concepts#update-function
 public struct Update<Model, Event, Effect> {
-    private let update: (Model, Event) -> Next<Model, Effect>
+    @usableFromInline let updateClosure: (Model, Event) -> Next<Model, Effect>
 
     /// Creates an `Update` struct wrapping the provided function.
     public init(_ update: @escaping (Model, Event) -> Next<Model, Effect>) {
-        self.update = update
+        self.updateClosure = update
     }
 
     /// Invokes the update function.
+    @inlinable
     public func update(model: Model, event: Event) -> Next<Model, Effect> {
-        return self.update(model, event)
+        return updateClosure(model, event)
     }
 
     /// Invokes the update function.

MobiusCore/Source/MobiusController.swift

@@ -129,7 +129,7 @@ public final class MobiusController<Model, Event, Effect> {
         // Wrap initiator (if any) in a logger
         let actualInitiate: Initiate<Model, Effect>
         if let initiate = initiate {
-            actualInitiate = LoggingInitiate(initiate, logger: logger).initiate
+            actualInitiate = logger.wrap(initiate: initiate)
         } else {
             actualInitiate = { First(model: $0) }
         }

MobiusCore/Source/MobiusLoop.swift

@@ -117,7 +117,7 @@ public final class MobiusLoop<Model, Event, Effect>: Disposable, CustomDebugStri
         logger: AnyMobiusLogger<Model, Event, Effect>
     ) -> MobiusLoop where EffectHandler.Input == Effect, EffectHandler.Output == Event {
         let accessGuard = ConcurrentAccessDetector()
-        let loggingUpdate = update.logging(logger)
+        let loggingUpdate = logger.wrap(update: update)
         let workBag = WorkBag(accessGuard: accessGuard)
 
         // create somewhere for the event processor to push nexts to; later, we'll observe these nexts and

MobiusCore/Test/LoggingInitiateTests.swift

@@ -25,21 +25,21 @@ class LoggingInitiateTests: QuickSpec {
     override func spec() {
         describe("LoggingInitiate") {
             var logger: TestMobiusLogger!
-            var loggingInitiate: LoggingInitiate<String, String>!
+            var loggingInitiate: Initiate<String, String>!
 
             beforeEach {
                 logger = TestMobiusLogger()
-                loggingInitiate = LoggingInitiate({ model in First(model: model) }, logger: logger)
+                loggingInitiate = logger.wrap { model in First(model: model) }
             }
 
             it("should log willInitiate and didInitiate for each initiate attempt") {
-                _ = loggingInitiate.initiate("from this")
+                _ = loggingInitiate("from this")
 
                 expect(logger.logMessages).to(equal(["willInitiate(from this)", "didInitiate(from this, First<String, String>(model: \"from this\", effects: []))"]))
             }
 
             it("should return init from delegate") {
-                let first = loggingInitiate.initiate("hey")
+                let first = loggingInitiate("hey")
 
                 expect(first.model).to(equal("hey"))
                 expect(first.effects).to(beEmpty())

MobiusCore/Test/LoggingUpdateTests.swift

@@ -29,7 +29,7 @@ class LoggingUpdateTests: QuickSpec {
 
             beforeEach {
                 logger = TestMobiusLogger()
-                loggingUpdate = Update { model, event in Next(model: model, effects: [event]) }.logging(logger)
+                loggingUpdate = logger.wrap(update: Update { model, event in Next(model: model, effects: [event]) })
             }
 
             it("should log willUpdate and didUpdate for each update attempt") {