         // If we received a transformed subscription, we subscribe to that subscription
         // and forward all new values to the subscriber.
         if let transformedSubscription = transformedSubscription {
-            transformedSubscription.observe { [unowned self] _, newState in
+            transformedSubscription.observer = { [unowned self] _, newState in
                 self.subscriber?._newState(state: newState as Any)
             }
         // If we haven't received a transformed subscription, we forward all values
         // from the original subscription.
         } else {
-            originalSubscription.observe { [unowned self] _, newState in
+            originalSubscription.observer = { [unowned self] _, newState in
                 self.subscriber?._newState(state: newState as Any)
             }
         }

    public func skipRepeats(_ isRepeat: @escaping (_ oldState: State, _ newState: State) -> Bool)
        -> Subscription<State> {
        return Subscription<State> { sink in
            self.observe { oldState, newState in
                switch (oldState, newState) {
                case let (old?, new):
                    if !isRepeat(old, new) {

        }
    }

    /// The closure called with changes from the store.
    /// This closure can be written to for use in extensions to Subscription similar to `skipRepeats`
    public var observer: ((State?, State) -> Void)?

    // MARK: Internals

    init() {}

    /// Sends new values over this subscription. Observers will be notified of these new values.
    func newValues(oldState: State?, newState: State) {
        self.observer?(oldState, newState)
    }
}

