Swift中的柯里化Currying

引子：在上一篇文章中，咱们使用到了"Curry"。若是你看了这个框架的源代码的话，可能有点犯晕（有可能只有我一我的这样，你们都是大神）。这篇文章就是关于这个“柯里化”的内容，参考了库做者的博客以及喵神的 tips 和Ole Begemann的文章。顺便说一句喵神出书，能够去支持一下。

什么是柯里化(Currying)

首先，咱们来看个简单的例子：

func add(a: Int,b: Int) -> Int{
    return a + b
}

这个函数很容易理解，就是一个整型求和的函数，函数接收两个整型做为参数，并返回两个参数相加的结果。咱们能够直接使用该函数：

let sum: Int = add(2,b: 3)  //sum = 5

当咱们但愿将一个整数数组里面的全部数据都增长一个基数的时候，咱们能够进行以下的操做：

let xs = 1...10  
let x = xs.map {
    return add($0,b: 2)
}  
// x = [3,4,5,etc]

在代码中，咱们先声明并初始化了一个整型数组，而后用map方法是数组里面的元素都增长了2，并将结果保存到新的数组中。其中$0表示当前迭代到的元素。在代码中，咱们使用了闭包(closure)，而且传递了一个默认参数。可是当在多处使用相似功能的时候，每次都写闭包仍是不够精简。下面作第一步改进：

func addTwo(a: Int) -> Int {
    return add(a, 2)
}

let xs = 1...10
let x = xs.map(addTwo)  // x = [3,4,5,etc]

可是这个改进有明细的不足，就是默认参数是写死的。当咱们要将默认参数设为3的时候咱们不得从新写一个函数addThree，这显然不符合代码复用的要求。咱们进一步作出修改：

func add(a: Int) -> (Int -> Int) {
    return { b in  
        a + b  
    }  
}

这个函数看起来是否是有点晕啊。咱们来一步步分析一下这个函数，首先，函数接收一个整型参数a，函数的返回值是一个Int -> Int 的函数类型，在这个返回的函数类型也会传入一个参数，以及返回一个值（参数a是函数add传入，参数b是闭包里的，返回值是a + b）,这意味这两件事：

1. 若是咱们直接调用该函数的化，咱们须要使用两个括号来区分这两个参数，形如：

   let sum = add(2)(3)  //sum = 5

2. 咱们能够经过传递一个参数个该函数，那么他会返回一个接收一个参数的新函数。若是咱们再传入一个参数给这个返回的无名函数，那么就会返回一个咱们想要的结果：

   let addTwo = add(2)
      let xs = 1...100
      let x = xs.map(addTwo) // x = [3, 4, 5, 6, etc]

上面的柯里化函数的另一种更容易理解的形式是：

func add(a: Int)(num: Int) -> Int {
    return a + num
}

//直接调用的形式与上面略有不一样：

let sum = add(2)(num: 3) // sum = 5

综上，咱们能够将柯里化的进行以下描述：

柯里化就是将一个接收多参数的函数，改造为接收第一个参数，而后返回一个接收余下参数的新方法。柯里化最大的一个好处就是代码复用便于维护，以及量产相似的方法。

//批量产生相似方法：    
let addTwo = add(2)
let addThree = add(3)
let addFour = add(4)

进一步理解柯里化(Currying)

咱们看看下面的简单实例：

class BankAccount {
    var balance: Double = 0.0

    func deposit(amount: Double) {
        balance += amount
    }
}

咱们最多见的用法：

let account = BankAccount()
account.deposit(100)  // balance is now 100

下面看一个很是规的用法：

let depositor = BankAccount.deposit
depositor(account)(100)  // balance is now 200

咱们看见下面的操做实现的效果于上面的那个是同样的。让咱们来分析一下这个很是规的操做。首先，第一步将函数deposit函数赋值给变量depositor，咱们能够看见BankAccount.deposit后面并无常见的括号。此时的depositor实际上是一个BankAccount -> (Double) -> ()类型的实例，有点相似于C中的函数指针。能够在playground右侧看见类型信息，见下图。

BankAccount.deposit()传入参数account其实就是实现绑定。

也就是说depositor传入一个BankAccount类实例做为参数会返回一个Double -> ()类型的函数，再传入一个参数就能够实现变量的叠加了。上面的很是规作法能够进一步简化：

BankAccount.deposit(account)(100) //balance is now 300

到目前为止，咱们只是对一些本身的函数或者自定义类的函数上应用了柯里化，那么如何在系统或者第三方库中应用这种有益的特性呢？咱们看下面的例子，主要用到了拓展和泛型。

extension NSNumber {

    class func multiple(left: Int, right:Int) -> Int {
        
        return left * right
        
    }

}

func curry(function: (Int,Int) -> Int) -> (Int -> (Int -> Int)){
    
    return { a in
        
        { b in
            return function(a,b)
        }
        
    }
    
}

首先咱们拓展了NSNumber，定义了一个整型的乘法运算函数。而后y又定义了一个curry函数，该函数看起来很是复杂，咱们来一步步来分析。首先curry函数接受一个函数类型的参数类型为(Int,Int) -> Int ，而后会返回一个函数类型Int -> (Int -> Int)，而后再传入一个整型给该返回类型，回继续返回一个Int -> Int函数类型，再传入参数才会获得最会结果。接下来看函数内部，return语句首先返回了一个闭包，该闭包就是Int -> (Int -> Int)类型：

｛ a in 
    //....
 }

再看下一层闭包，类型是(Int -> Int)，在最内层的闭包中会将上两层闭包传入的参数a、b进行function操做。可是这并非最通用的作法，还能改进。可使用泛型的特征使curry函数不受参数类型限制。具体实现：

extension NSNumber {
    
    class func multiple(left: Int, right:Int) -> Int {
        
        return left * right
            
    }
    
    class func add(left:Double, right:Double) -> Double {
            
        return left + right
            
    }
    
}  

func curry<A, B, C>(function: (A,B) -> C) -> (A -> (B -> C)){
    
    return { a in
                
        { b in
            return function(a,b)
        }
                
    }
    
} 

curry(NSNumber.multiple)(2)(3)      // 6
curry(NSNumber.add)(2.0)(3.0)       // 5.0

具体的类型能够在playground右侧查看。

熟悉了解柯里化的特性后，之后就能够本身写个高复用的类库了，固然也可使用上篇文章中提到的Curry类库