Transform

接触过FP的应该都知道map，RxSwift也提供对应的方法将Element进行变形，主要的方法有buffer, flatMap, flatMapFirst, flatMapLatest, map, scan和window， 用的比较多的是map和flatMap。

map

let disposeBag = DisposeBag()
Observable.of(1, 2, 3)
    .map { "\($0)\($0)" }
    .subscribeNext { print($0) }
    .addDisposableTo(disposeBag)

根据map的定义：

public func map<R>(selector: E throws -> R) -> Observable<R> {
    return self.asObservable().composeMap(selector)
}

selector这个closure负责将E转换为R，而E这里被定义为Observable.of(1, 2, 3)的Int，每个元素会被转换为String。

flatMap

let disposeBag = DisposeBag()
let sequenceInt = Observable.of(1, 2, 3)
let sequenceString = Observable.of("A", "B", "C", "D")

sequenceInt.flatMap { _ in
        return sequenceString
    }
    .subscribe { print($0) }
    .addDisposableTo(disposeBag)

flatMap的定义：

public func flatMap<O: ObservableConvertibleType>(selector: (E) throws -> O) -> Observable<O.E> {
    return FlatMap(source: asObservable(), selector: selector)
}

来看看Rx官方给出的描述：

map	flatMap
Transform the items emitted by an Observable by applying a function to each item	Transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable

map和flatMap的区别在于map的selector将用于Observable中的每一个Element，操作完成后，Element的数量和源Observable中的是一样的，而flatMap的selector的调用次数和源Element数量一致，但是由于selector的返回值为一个Observable，所以在操作完成后，得到的Elements为源Element数量*selector返回的Observable的Element数量，然后将所有Element放入一个Observable中，类似于[[1, 2], [2, 3], [3, 4]] -> [1, 2, 2, 3, 3, 4]。

flatMap

flatMapLatest

比起map和flatMap，要稍微难理解一点：

let disposeBag = DisposeBag()

[1, 2, 3].toObservable()
    .flatMapLatest { value  in
        return ["\(value)a", "\(value)b"].toObservable()
    }
    .subscribe { print($0) }
    .addDisposableTo(disposeBag)

根据RxJS flatMapLatest这个代码期望的结果是（RxSwift和Rx系的其他语句具有相似接口，其中RxJava对应的方法是switchMap，在RxJS Source Code也能发现其实它和switchMap是一个函数）：

Next(1a)
Next(2a)
Next(3a)
Next(3b)
Completed

但是实际上得到的输出结果是：

Next(1a)
Next(1b)
Next(2a)
Next(2b)
Next(3a)
Next(3b)
Completed

出现这种情况的原因在github的Get Start有解释，问题出现在selector中的toObservable，它的实现使用了Sequence:

public func toObservable(scheduler: ImmediateSchedulerType? = nil) -> Observable<Generator.Element> {
    return Sequence(elements: self, scheduler: scheduler)
}

Sequence其实是一个同步队列的实现，在subscribe调用前会生成Next和Completed，因为无论哪种disposable被返回，生成elements的过程都不能被打断。在这种情况下，flatMapLatest和flatMap的输出结果一样。

期望的版本:

let disposeBag = DisposeBag()
var charValues: [Variable<Character>] = [Variable("a"), Variable("a"), Variable("a")]

[0, 1, 2].toObservable()
    .flatMapLatest { value -> Observable<Character> in
        print("Int value: \(value)")
        return charValues[value].asObservable()
    }
    .subscribe { print($0) }
    .addDisposableTo(disposeBag)

charValues[2].value = "b"
charValues[0].value = "c"   // nothing happen
charValues[1].value = "d"   // nothing happen

flatMapLatest

和flatMap一样，flatMapLatest也会新生成一个Observable的队列，但不同的是它不会合并所有的新Observable中的Element，它会switch到最后一个Observable上（switchMap这个名字感觉更容易让人理解一点），先前建立的Observable将不再被监听，所以代码中charValues只有最后一个Observable还在被subscribe。

scan

let disposeBag = DisposeBag()
Observable.range(start: 1, count: 3)
    .scan(0) { $0 + $1 }
    .subscribe { print($0) }
    .addDisposableTo(disposeBag)

scan和swift的原生方法reduce很类似（区别在于scan后的Element数量和源Element数量一致，但是reduce只会返回一个Element），在Observable+Single中我们能够找到它的定义：

public func scan<A>(seed: A, accumulator: (A, E) throws -> A) -> Observable<A> {
    return Scan(source: self.asObservable(), seed: seed, accumulator: accumulator)
}

seed的scan开始的初始值，accumulator的第一个参数为上一次操作的返回值，第二个参数为Observable队列中的Element，然后返回处理结果。