         let testScheduler = TestScheduler(initialClock: 0)
         var testableObserver: TestableObserver<Int>!
         var subscriptionState: [Int] = []
-        let timer = testScheduler.createColdObservable([
-            next(50, 0),
-            completed(50)
-            ])
+        let timer = testScheduler.createColdObservable(
+            [
+                next(50, 0),
+                completed(50),
+        ])
             .asSignal(onErrorJustReturn: 0)
 
         SharingScheduler.mock(scheduler: testScheduler) {
-
-            let player: Feedback = react(query: { $0 }, effects: { state in
-                return timer.map { _ in 1 }
+            let player: Feedback = react(
+                query: { $0 }, effects: { _ in
+                    timer.map { _ in 1 }
             })
 
             let mockUIBindings: Feedback = RxFeedback.bind { (state: Driver<State>) in
                 let subscriptions: [Disposable] = [
-                    state.drive(onNext:{ subscriptionState.append($0) })
+                    state.drive(onNext: { subscriptionState.append($0) }),
                 ]
                 return Bindings(subscriptions: subscriptions, mutations: [Observable<Mutation>]())
             }
             let system = Driver.system(
                 initialState: 0,
                 reduce: { oldState, mutation in
-                    return oldState + mutation
+                    oldState + mutation
                 },
-                feedback: mockUIBindings, player
-            )
+                feedback: mockUIBindings, player)
 
             testableObserver = testScheduler.createObserver(Int.self)
-            let _ = system.drive(testableObserver)
-            testScheduler.scheduleAt(200, action: {
-                testScheduler.stop()
+            _ = system.drive(testableObserver)
+            testScheduler.scheduleAt(
+                200, action: {
+                    testScheduler.stop()
             })
             testScheduler.start()
         }

        let system = Driver.system(
            initialState: "initial",
            reduce: { oldState, append in
                return  oldState + append
            },
            feedback: RxFeedback.bind { (stateAndScheduler) in
                let results = stateAndScheduler.flatMap { state -> Signal<String> in
                    if state == "initial" {
                        return Signal.just("_a").delay(0.01)

                    }
                }
                return Bindings(subscriptions: [], mutations: [results])
        })

        let result = (
            try?
                system
                .asObservable()
                .take(4)
                .timeout(0.5, other: Observable.empty(), scheduler: MainScheduler.instance)
                .toBlocking(timeout: 3.0)
                .toArray()) ?? []

        XCTAssertEqual(
            result, [
                "initial",
                "initial_a",
                "initial_a_b",
                "initial_a_b_c",
        ])
    }

    func testBindingsAreNotDisposedWhenNoMutationsAreSpecifiedOnDriverSystem() {
        typealias State = Int
        typealias Mutation = Int
