ReactiveX is a combination of the best ideas from the Observer pattern, the Iterator pattern, and functional programming

入坑RxSwift之前，需要理解的几个核心概念

• Observable
• Observer
• Disposables

RxSwift是一种事件驱动的函数式编程框架，这个框架的核心是监听者模式。 所有的事件都是可以订阅的。

-next(1)-next(2)-next(3)-next(4)-next(5)-next(6)- -error(Error)- -completed-

Observable本身是一个可被订阅的序列，类似于一个管道，特定类型的事件，排列在管道中，等待订阅者的监听，然后依照次序，发送给订阅者。

Observer是订阅者，通过订阅获取序列中的元素

Disposables用于管理一个订阅的生命周期

RxSwift

Disposables内存管理相

Observable

isEqual Quence 相当于一个列表，列表里面是Event 所有的 subscribe、bind、disposed都是基于Observable这个Queue来进行的。 Event是一个Enum，包含三种状态

• next(Element)
• error(Swift.Error)
• completed

其中，next中包含了Event中改变的值，error中包含了错误信息，completed终止当前序列。

Variable = 容器

将普通对象、包装成一个可被监听的对象。

Observer

Scheduler

多线程管理

Subjects

RxCocoa

ControlProperty 特点

• 不会失败
• 当Control被内存释放时（dealloc），会自动调用Completed
• 只在MainScheduler中发送Event.
• shareReplay(1) behavior
  • it's stateful, upon subscription (calling subscribe) last element is immediately replayed if it was produced

ControlEvent

- it never fails
- it won't send any initial value on subscription
- it will `Complete` sequence on control being deallocated
- it never errors out
- it delivers events on `MainScheduler.instance`

public protocol ObservableConvertibleType {
    associatedtype E
    func asObservable() -> Observable<E>
}
public protocol ObserverType {
    func on(_ event: Event<E>)
}
public protocol ObservableType : ObservableConvertibleType {
    func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E
}
public protocol ControlPropertyType : ObservableType, ObserverType {
    /*
    Trait for `Observable`/`ObservableType` that represents property of UI element.

    Sequence of values only represents initial control value and user initiated value changes.
    Programatic value changes won't be reported.
    */
    func asControlProperty() -> ControlProperty<E>
}

public class Observable<Element> : ObservableType {
    /// Type of elements in sequence.
    public typealias E = Element
    public func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.E == E {
        rxAbstractMethod()
    }
    public func asObservable() -> Observable<E> {
        return self
    }
    /// Optimizations for map operator
    internal func composeMap<R>(_ transform: @escaping (Element) throws -> R) -> Observable<R> {
        return _map(source: self, transform: transform)
    }
}

public enum Event<Element> {
    case next(Element)
    case error(Swift.Error)
    case completed
}

public final class Variable<Element> {
    public typealias E = Element
    private let _subject: BehaviorSubject<Element>
    private var _lock = SpinLock()
    private var _value: E
    public var value: E {
        get {
            _lock.lock(); defer { _lock.unlock() }
            return _value
        }
        set(newValue) {
            #if DEBUG
                _synchronizationTracker.register(synchronizationErrorMessage: .variable)
                defer { _synchronizationTracker.unregister() }
            #endif
            _lock.lock()
            _value = newValue
            _lock.unlock()

            _subject.on(.next(newValue))
        }
    }
    public init(_ value: Element) {
        _value = value
        _subject = BehaviorSubject(value: value)
    }
    public func asObservable() -> Observable<E> {
        return _subject
    }
    deinit {
        _subject.on(.completed)
    }
}