如何用 Swift 优雅地写一个 JSON 解析函数？（下）——

如何用 Swift 优雅地写一个 JSON 解析函数？（上）—— 泛型及扩展
阅读这一篇文章，你需要对函数式编程和协议有一定的了解。
这里用到的代码我都写在了 playground 里，放到了 Github 上。
如果你对函数式编程不甚了解，可以看一看我之前的文章：
Swift 函数式编程探索（1）—— Functor 和 Monad
Swift 函数式编程探索（2）——实践中使用 Functor 和 Monad
Swift 函数式编程探索（3）—— Applicative 和 Curry

我们接着往下说。

5、使用 faltMap 、 Applicative 、以及 Curry

这一部分，许多来自 @chriseidhof 大神的这篇文章 ：Parsing JSON in Swift

我们先来看看这一步之后的最终结果：

func parseUser5(json: JSON?) -> User? {
    let curryUser = curry(User.init)
    return json >>- {
        curryUser <*> ("uid".fatch($0) >>- toInt64)
            <*> "nam".fatch($0)
            <*> "ada".fatch($0)
            <*> "sgt".fatch($0)
            <*> ("rgt".fatch($0) >>- toDate)
    }
}
let user5 = parseUser5(userJSON)

相比之下，是不是简洁了很多？
如果你觉得看不懂，那么我来一步一说明：

let curryUser = curry(User.init)

这是使用 curry 方法接收 User 的初始化器，返回一个柯里化的初始化方法，curry 是这样的：

func curry<A,B,C,D,E,R>(fun: (A,B,C,D,E) -> R) -> A -> B -> C -> D ->E -> R {
    return { a in { b in { c in { d in { e in fun(a,b,c,d,e) } } } } }
}

curryUser其实是一个Int64 -> String -> Bool? -> String? -> NSDate? -> User类型
继续往下看，>>-也是 flatMap ，是这样定义的 ：

infix operator  >>- { associativity left }

public func >>- <U,T> (a : U? , @noescape f: U throws -> T?) rethrows -> T? {
    return try a.flatMap(f)
}

parseUser5 中 return 的那一行，表示的是 json flatMap 了一个闭包

{
    curryUser <*> ("uid".fatch($0) >>- toInt64)
        <*> "nam".fatch($0)
        <*> "ada".fatch($0)
        <*> "sgt".fatch($0)
        <*> ("rgt".fatch($0) >>- toDate)
} //(JSON) -> User?

<*> 符号是一个 Apply ，它是这样定义的：

extension Optional {
    func apply<T>(f: (Wrapped -> T)?) -> T? {
        if let f = f {
            return self.map(f)
        }
        return nil
    }
}

infix operator <*> { associativity left }

func <*><U, T>(f: (U -> T)?, a: U?) -> T? {
    return a.apply(f)
}

("uid".fatch($0) >>- toInt64) 表示将闭包接收到的参数进行 fatch 操作后（可能得到 nil） flatMap 函数 toInt64

func toInt64(input: Int?) -> Int64? {
    return input.map{ Int64($0) }
}

上面的那个闭包中，curryUser 先是接受了一个可能为空的 Int64 （空就返回 nil ），得到一个 String -> Bool? -> String? -> NSDate? -> User类型。
如此类推，这个闭包接收一个 JSON 类型的参数，返回一个 User 或者 nil
但是这里其实是有一点问题的。
在接受了 Int64 和 String 各表示 userId 和 name 之后，再往下的参数，是可以为空的，但是我们这里实现的 apply ，只要是任意一边为空，就会返回空。

let otherJSON  = [
    "uid": 2,
    "nam": "FrainTest",
//  "sgt": "buzy",
    "ada": true,
    "rgt": "2016-03-04"
]

let other = parseUser5(otherJSON)  // nil

换句话说，只要返回的 JSON 中不含有某一个参数即便是可以为空的参数，整个都会是空。
怎么解决这个问题呢？
我们可以这样再定义一个 apply 吗？

extension Optional {
    func apply<T>(f: (Wrapped? -> T)?) -> T? {
        if let f = f {
            return f(self)
        }
        return nil
    }
}

func <*><U, T>(f: (U? -> T)?, a: U?) -> T? {
    return a.apply(f)
}

理论上来说，这是可以的。为什么说是理论上？
经过测试，如果单一使用，是可以的。
但是实际上，在这种情况，编译器并不能很容易地区分两个 apply ，在运行一段时间后，就会说这里 too complex
所以我们定义一个新的操作符执行这种特定的 Apply：

infix operator <%> { associativity left }

func <%><U, T>(f: (U? -> T)?, a: U?) -> T? {
    return a.apply(f)
}

这样使用：

func parseUser6(json: JSON?) -> User? {
    let curryUser = curry(User.init)
    return json >>- {
        curryUser <*> ("uid".fatch($0) >>- toInt64)
            <*> "nam".fatch($0)
            <%> "ada".fatch($0)
            <%> "sgt".fatch($0)
            <%> ("rgt".fatch($0) >>- toDate)
    }
}

let user6 = parseUser6(otherJSON)

就没有问题了。
接下来，我们就可以着手解析整个 json 了，同样使用函数式编程，这一次我们需要用到 SequenceType 的 flatMap ，补充上：

public func >>- <S: SequenceType, T>(
    a: S, @noescape f: S.Generator.Element throws -> T?) rethrows -> [T] {
    return try a.flatMap(f)
}

于是我们就可以这样解析：

func parseJSON(json: JSON?) -> [User]?  {
    let jsons: [JSON]? = json >>- "data".fatch >>- "users".fatch
    return jsons  >>- { $0 >>- parseUser6 }
}

parseJSON(json)

这样，是不是足够优雅了呢？
其实还可以再优雅一点，我们结合前面提到的泛型和扩展：

6. 使用 Protocol

我们定义一个这样的协议：

protocol JSONDeserializable {
    init?(json: JSON?)
}

这个解析要求实现一个可失败的接收 JSON 的初始化器，我们让 User 类 adopt 这个协议：

extension User: JSONDeserializable {
    init?(json: JSON?) {
        let curryUser = curry(User.init)
        guard let user = json >>- {
            curryUser <*> ("uid".fatch($0) >>- toInt64)
                <*> "nam".fatch($0)
                <%> "ada".fatch($0)
                <%> "sgt".fatch($0)
                <%> ("rgt".fatch($0) >>- toDate)
        } else { return nil }
        self = user
    }
}

这有什么用呢？我们可以结合扩展和泛型，这样写：

extension String {
    func fromParse<T: JSONDeserializable>(json: JSON?) -> [T]?  {
        let jsons: [JSON]? = json >>- "data".fatch >>- self.fatch
        return jsons >>- { $0 >>- T.init }
    }
}

然后这样用：

func doSomeThingWithUser(users: [User]) {
    print(users)
}

"users".fromParse(json) >>- doSomeThingWithUser

假如我们以后又有了新的数据类型希望能够通过 JSON 创建，只要实现这个协议，就能通过这个泛型函数接受 JSON 来创建（毕竟一般JSON格式相同）

最后

到这里，我们的解析函数已经很简洁，也足够的优雅
就像我一开始说的，这里的目的，是分享一种将 Swift 的各种特性好好利用的一种可能性，我相信还有更好的解决方法，也欢迎大家交流。