“将一个接受多参数的函数变换为一系列只接受单个参数的函数，这个过程被称为柯里化 (Currying)，它得名于逻辑学家 Haskell Curry；” — 摘录来自: Chris Eidhof. “函数式 Swift”。 iBooks.

注：本文大部分内容来自coursera课程 Functional Programming in Scala，原文使用Scala实现，这里使用大家更为熟悉的Swift 语言

多参数函数变换为单个参数的函数

先看一个加法例子:

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

这是一个简单的计算两个数相加的函数。调用的方法也很简单:
add(1, 2)

使用柯里化的思想来看待这个函数会发生什么呢？
上文已经说明，柯里化的思想是将多参数函数变换为单个参数函数，那我们的add函数需要改变一下:

func add(_ a: Int) -> ?

为了计算两个数的和，当然需要传入两个数。如果将add函数的参数变为一个，那add函数的返回值应该是什么呢？
答案是接受单个参数的另一个函数。
这里就是柯里化的核心思想：我们计算两个数相加，可以看作传入一个参数，返回一个需要传入第二个加数的函数。
也就是这样:

• 未柯里化: a ,b -> a + b
• 柯里化: a -> (b -> Int)
  也就是说，a和b相加可以看作传入参数a之后，返回了一个需要传入b的函数，此时再将b作为参数传入，便得到了两个数相加的结果。
  add函数的柯里化版本:

func add(_ a: Int) -> ((Int) -> Int) {
    return {a + $0}
}

尝试调用add函数:
add(1)(2)
我们得到了同样的结果。
现在的add函数返回值已经从简单的数字变成了一个函数（这里使用了闭包），这个函数接受另一个数作为参数，计算出两个数的和。
对比一下两种写法的调用形式:

add(1,2)
add(1)(2)

那么为什么要使用这种看起来更加复杂的函数式方法呢？

更加复杂的例子

来自coursera的课程内容
我们现在想要计算某个数字区间内以某种方式计算之后的和，比如:
1..3 之间的平方和: 1^2 + 2^2 + 3^3
我们可以这样定义这个函数:

func sumSquare(_ a: Int, _ b: Int) -> Int {
    func loop(_ a: Int, _ acc: Int) -> Int {
        guard a <= b else {
            return acc
        }
        return loop(a + 1, a*a + acc)
    }
    return loop(a, 0)
}

这里使用了 递归
我们调用这个函数:
sumSquare(3, 4)
得到结果为: 25

如果我们想要计算3，4区间里的立方和呢？此时我们想到应该在求和的函数的参数中传入不同的计算方法，也就是传入计算方法的函数，此时我们的和函数应该是这样的:

func sum(f: @escaping (Int) -> Int, _ a: Int, _ b: Int) -> Int {
    func loop(_ a: Int, _ acc: Int) -> Int {
        guard a <= b else {
            return acc
        }
        return loop(a + 1, f(a) + acc)
    }
    return loop(a, 0)
}

我们传入了一个计算方法的函数f，此时求和函数可以根据我们传入的f的不同形成不同的求和结果。试一下立方和:
sum(f: {$0 * $0 * $0}, 1, 2)
结果为: 9 -> (1 + 2 * 2 * 2)
为了构建不同的和函数，我们需要写大量这样的代码，有没有方法能简化这段求和代码呢？使用柯里化试一试:
不同的求和函数只有计算方法不同，那我们将计算方法抽象出来。求和函数不返回求和之后的值，而是返回一个需要两个整数作为参数来表示区间的函数。柯里化之后应该是这样的:

typealias operatorF = (Int) -> Int
typealias fSum = (Int, Int) -> Int

func sum(_ f: @escaping operatorF) -> fSum {
    func sumF(a: Int, b: Int) -> Int {
        guard a <= b else {
            return 0
        }
        return f(a) + sumF(a: a + 1, b: b)
    }
    return sumF
}

为了表达的更清晰，我们使用了自定义别名，operatorF表示计算方法，fSum表示sum函数的返回值－－－也是一个函数，这个函数接收两个参数，返回一个整数。
这时我们再来构建不同计算方法的求和函数:

• 平方和:

func sumSquare() -> fSum {
    return sum{$0 * $0}
}

调用一下:
sumSquare()(3,4)
结果为: 25。正确
此时我们根据sum函数可以构建出更多并且相互独立的函数，比如立方和:

• 立方和:

func sumCube() -> fSum {
    return sum{$0 * $0 * $0}
}

通过上面的示例，我们已经可以发现柯里化的优点了：使用柯里化的思想可以构建出更为独立，重用性更高的代码。

注：这篇文章只是用于自己学习过程中的回顾和总结，远远没有达到探讨专业的地步，如果大家对函数式编程感兴趣，可以查阅资料，大家一同学习，欢迎提出建议和批评。