Currying 也是 Swift 的众多先进特性之一，用一句话说就是将接受多个参数的函数，转变成每次之接受一个参数的调用序列。

上面一句话说得可能大家感觉不是那么清楚，那么没关系，咱们举一个例子来说明吧。

比如，我们需要一个两个数字相加的函数，我们可以这样定义：

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

    return a + b

}

那么，我们直接这样调用，就可以得到结果了：

add(1, b: 2)

这个是最基本的使用角度，那么假如我们把思维提升一个层级，比如:

let numbers = 1...10

let added = numbers.map {

    return add($0, b: 2)

}

这里我们先用 1...10 声明了一个整数数组，然后用它的 map 方法将数组中所有的元素都加 2 然后生成一个新的数组。

注： add($0, b: 2) 中的 $0 表示当前遍历到得数组元素，把它传递给 add 函数并且加 2 后返回，生成新的数组元素。

这样做好像也没什么问题，但实际上我们完全可以不使用闭包来处理 map 中的回调。我们还可以这样：

func add(a:Int) -> (Int -> Int) {

    return { b in
        return a + b
    }

}

let numbers = 1...10
let added = numbers.map (add(2))

怎么样，有没有眼花缭乱呢？ 怎么 map 函数调用变成这个样子的呢：numbers.map (add(2))

相信手机或电脑前的一定很聪明，能看出端倪。

实际上我们是把 add 函数的定义做了修改：

func add(a:Int) -> (Int -> Int)

我们的 add 函数现在只接受一个参数了。并且呢，注意一下它的返回值类型：

(Int -> Int)

在 Swift 中，这种定义格式，表示的是一个函数类型。也就是说，我们的 add 函数它除了接受一个 Int 类型的参数，它还会返回一个函数类型的闭包对象。
接着，再看看这个函数的实现：

func add(a:Int) -> (Int -> Int) {

    return { b in
        return a + b
    }

}

确实，返回的是一个闭包对象，接受了一个参数 b，然后这个闭包对象，继续将 a 和 b 两个参数的值再次返回。

关于闭包的概念，可以参看咱们之前讨论过的文章：了解闭包

这么一来，就明了啦，add 函数其实是一个返回函数的函数。也可以把它看做一个函数生成器。它接受的参数作为它生成的函数的一个标准：

let addTwo = add(2)
let addThree = add(3)
let addFive = add(5)

就像上面的代码那样，给 add 函数传入不同的参数，它就会依照这个参数值，生成一个新的函数，而这个就会对它接受的参数与之前 add 指定的增量进行加法操作了。

嗯，绕了这么一大圈，我们刚才讨论的这种函数行为，就叫做 currying。

对于 add 函数呢，我们还可以有另外一种写法：

func add(a: Int)(b: Int) -> Int {

    return a + b

}

这样写出来的 add 函数以，就显得直观一些了。

然后，我们依然可以像这样，用它来生成各种新的函数：

let addTwo = add(2)
let addThree = add(3)
let addFive = add(5)

还可以向这样，把它作为另一个回调的传入：

let numbers = 1...10
let added = numbers.map (add(2))

总之呢，Swift 诞生之初，就有着它先天的强大与灵活。