ReSwift + Rx

RxStore.swift

import Foundation
import RxSwift

public class RxStore: StoreSubscriber {
    
    private var stateObservable:Observable<AppState> {
        return subject.asObserver()
            .shareReplay(1)
    }
    private var subject = PublishSubject<AppState>()
    private var store: Store<AppState>
    
    init(store: Store<AppState>) {
        self.store = store
        self.store.subscribe(self)
    }
    
    deinit {
        self.store.unsubscribe(self)
    }
    
    public func newState(newState: AppState) {
        subject.onNext(newState)
    }
    
    public func state<S:Equatable>(mapState:(AppState)->S) -> Observable<S>
    {
        return stateObservable
            .map(mapState)
            .distinctUntilChanged()
    }
    
}

var store = Store<AppState>(reducer: AppReducer(), state: nil, middleware: [rxMiddleware, loggingMiddleware])
var rxStore = RxStore(store: store)

rxStore.state { $0.userState }
  .subscribeNext { 
    print("user: \($0.user)")
  }
}

Hey @Odrakir, what is the reasoning behind the distinctUntilChanged() operator and requiring everything in state to be Equatable? Is this required?

Am using a reactive store extension in my project instead to great success. Exposes store.rx.state. Maybe you want to try that out, too:

//  Copyright © 2017 Christian Tietze. All rights reserved. Distributed under the MIT License.

import ReSwift
import RxSwift

extension ReSwift.Store: ReactiveCompatible { }

extension Reactive where Base: ReSwift.StoreType {

    var state: Observable<Base.State> {
        return Observable.create { observer in
            let subscriber = ReactiveStoreSubscriber<Base.State>()
            self.base.subscribe(subscriber)

            let forward = subscriber.state.subscribe(observer)
            let cancel = Disposables.create {
                self.base.unsubscribe(subscriber)
            }

            return Disposables.create(forward, cancel)
        }
    }
}

fileprivate class ReactiveStoreSubscriber<S>: StoreSubscriber {

    internal typealias StoreSubscriberStateType = S

    fileprivate let subject = PublishSubject<S>()

    internal var state: Observable<S> {
        return subject.asObservable()
    }

    func newState(state: StoreSubscriberStateType) {

        self.subject.onNext(state)
    }
}