Swift 函数式编程探索（3）—— Applicative 和 Curry

前两篇说了 monad 和 functor ，这两个算是比较经常会实际使用的。
这里说的两个函数式编程 Feature ，相对就没有那么广泛的使用了。
Applicative 和 Curry ，其中 applicative 并没有在 swift 中原生集成（虽然实现起来也很容易）， Curry 在 swift 3.0 中被移除了（虽然自己实现起来还是很容易）。
这里用到的代码我都写在了 playground 里，放到了 Github 上

这里简单说一下吧。

1. Applicative

只要实现了 Apply 函数如何作用于自身，就是一个 Applivative。

Optional 的 Apply

我们可以这样对 optional 和 SequenceType 扩充一个 apply 方法：

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

这样 Optional 就是一个 Applivative 了，我们可以这样来使用：

let b = Optional.Some(1)
let a = Optional.Some({ $0 + 1 })
b.apply(a)  // 返回 Optional(2)

SequenceType 的 Apply

我们同样可以对 SequenceType 扩充一个 apply 方法

extension SequenceType {
    func apply(fs: [Generator.Element -> T]) -> [T] {
        var result = [T]()
        for f in fs {
            for element in self.map(f) {
                result.append(element)
            }
        }
        return result
    }
}

这样一来 SequenceType 也是 Applicative 了。
我们可以怎么使用呢？

let plusTwoAndThree = [ { $0 * 2 }, { $0 * 3 } ]
let ints = [1, 2, 3]
ints.apply(plusTwoAndThree)  // 返回 [2, 4, 6, 3, 6, 9]

实践

和 functor 和 monad 类似，我们定义一个操作符 <*>

infix operator <*> { associativity left }

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

func <*>(f: [S.Generator.Element -> T], a: S) -> [T] {
    return a.apply(f)
}

然后我们就可以这样：

a <*> b
plusTwoAndThree <*> ints

2. Curry

简单地来说，Curry 就是一个生成方法的方法
比如说这里：

func operate(num: Int) -> (Int -> Int) -> Int {
    return {
        operate in operate(num)
    }
}

这是一个接收一个 Int 参数，返回一个接受一个 Int -> Int 参数的方法，再返回 Int
这么说可能有点绕，比如我们使用这个方法：

let operateOne = operate(1)  // (Int -> Int) -> Int

这里的 operateOne 就是一个生成的方法，它接受一个 Int -> Int 方法，然后返回 Int
我们可以拿这个 operateOne 这么使用：

let addOne: Int -> Int = { $0 + 1 }
let addTwo: Int -> Int = { $0 + 2 }

operateOne(addOne)  // 返回2
operateOne(addTwo)  // 返回3

使用 curry 能够量产方法，可以避免写一些重复的代码。

实践

在 swift 3.0 中，已经把 curry 函数移除了，详情可以见这里：
remove-currying

  // Before:
  func curried(x: Int)(y: String) -> Float {
    return Float(x) + Float(y)!
  }

像这种已经不能写了，但是可以用这种方法，也能轻易实现：

  // After:
  func curried(x: Int) -> (String) -> Float {
    return {(y: String) -> Float in
      return Float(x) + Float(y)!
    }
  }

但是我们不是都有机会去修改代码的，比如说一些第三方库什么的，我们可以用这样的泛型函数生成一个柯里函数：

func curry(fun: (A,B) -> R) -> A -> B -> R {
    return { a in { b in fun(a,b) } }
}

这么使用：

func operate(num: Int, f: Int -> Int) -> Int {
    return f(num)
}

let curryOperate = curry(operate)

curryOperate(1)(addOne)  // 返回 2

curry 和 applicative 也是函数式编程的重要部分，但是相对于 map 和 flatMap ，并没有在 swift 中那么多的使用，但是掌握了它们，仍然能为我们带来更好的开发思维，具体可以如何使用呢？
可以看一看我的这一篇：