一、Optional的map和flatMap

Optional 的定义

public enum Optional<Wrapped> : ExpressibleByNilLiteral {
    //我们在��写代码的时候，习惯用 nil 来表示空值，而不是 .none
    case none

    //非空的值用 Wrapped 来表示
    case some(Wrapped)

    //optional只有一个map函数，无�其它变体
    public func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U?  {
        switch self {
            case .some(let y):
            return .some(try transform(y))
            case .none:
            return .none
        }
    }

    //optional只有一个flatMap函数，无�其它变体
    public func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U?{
        switch self {
            case .some(let y):
                return try transform(y)
            case .none:
                return .none
        }
    }

map 和 flatMap的共性

map和flatMap函数的返回结果依旧是可选性；但返回的可选值类型可以与原可选值类型不一致。

• 如果�原optional没有值, map和flatMap函数都直接�返回nil。
• flatMap�：如果原optional有值�非空，则用解包后的值y做参数来�调用闭包transform，闭包的结果�就是flatMap的结果，transform(y)� ���降维。
• map：如果原optional有值�非空，则用解包后的值y做参数来�调用闭包transform，map的返回值是 .some( transform(y) )

例如：

// flatMap降维和 map的对比示例
let a: String? = "1"
let am = a.map{ Int($0) }       // 闭包结果类型 Int？    
print( am )  // Optional(Optional(1))  map结果类型 Int??  .some( transform(y) )

let afm = a.flatMap{ Int($0) }   // 闭包结果类型 Int？ 
print(afm)  //  Optional(1)    flatMap结果类型 Int??  transform(y)�

// 原来类型：Int?, 返回值类型：String?
let b: Int? = 1
let bm = b.map { String("result = \($0)") }   // 闭包结果类型 String
print(bm)   /// "Optional("result = 1")"

// 原optional没有值, map和flatMap函数都直接�返回nil
let c:Int? = nil            
let cm = c.map { String("result = \($0)") }   // 闭包结果类型 String
print(bm)   /// "nil"       map结果类型 String? 

结论：那什么时候使用flatMap 方法呢？答案是：当我们的闭包transform(y)的��返回值�是可选型的��时候，可以用f�latMap来降一次维。

二、Sequence 的� flatMap: 去空降维

每调用一次flatMap就去一次空、或降一次维

• 去空：把空值nil过滤掉。
• 降维：比如把�二维数组压平成一维数组。
• 每次调用只能2选一（去空、或降维），�这2个功能各自对应一个不同的重载flatMap函数。

extension SequenceType {
    // 去空：把空值nil过滤。 
    public func flatMap<T>(transform: (Self.Generator.Element) -> T?)   ->  [T]

    // 降维：比如把二维数组压平成一维数组
    public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) -> S)  ->  [S.Generator.Element]

// [Int?]  ->  [ Int ]   去空
var a = [1, 3, 5, nil, 7, 9]             // a 类型 [Int?]
let afm = a.flatMap{ $0 }             // afm 类型是 [ Int ]
print(type(of: afm), ": ", afm)    /// [1, 3, 5, 7, 9]


// [ [Int] ] -> [ Int ]  降维
var b = [[1, 3, 5], [7, 9] ]          // b 类型 [ [Int] ]
let bfm = b.flatMap{ $0 }           // bfm 类型 [ Int ]
print(type(of: bfm),": ", bfm)  /// [1, 3, 5, 7, 9 ]


// [ [Int]? ] -> [ [Int] ]  去空
var c = [ [1, 3, 5], [7, 9], nil ]  // c 的类型是 [ [Int]? ]
let cfm = c.flatMap{ $0 }           // cfm 类型  [ [Int] ]
print(type(of: cfm),": ", cfm)  /// [[1, 3, 5], [7, 9] ]


// [ [Int?] ]  -> [ Int? ]   降维
var d = [ [1, 3, 5], [7, 9], [nil] ]  // c 的类型是 [ [Int?] ]
let dfm = d.flatMap{ $0 }              // dfm 类型 [ Int? ]
print(type(of: dfm),": ", dfm) /// [1, 3, 5, 7, 9, nil ]


// [ [Int?]? ]  -> [ [Int?] ]  去空
var e = [ [1, 3, 5], [7, 9], [nil],  nil ]  // c 的类型是 [ [Int?]? ]
let efm = e.flatMap{ $0 }                    // efm 类型 [ [Int?] ]
print(efm) /// [[1, 3, 5], [7, 9], [nil], [10] ]

结论： 最好在操作 flatMap 时， 最好显示声明类型，这样可以更清晰的知道应该调用多少次flatMap，如：

// [ [Int?]? ]  -> [ Int ]  一看就知道要调用3次。
var f:  [ [Int?]? ] = [ [1, 3, 5], [7, 9], [nil],  nil ]         // c 的类型是 [ [Int?]? ]
let ffm3: [ Int ] = f.flatMap{ $0 }.flatMap{ $0 }.flatMap{ $0 }   // efm 类型 [ Int ]
print(ffm3) /// [1, 3, 5, 7, 9]