什么是柯里化函数：
柯里化（英语：Currying）是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。
简单说：柯里化函数就是，你有一个接收参数的函数，你只提供给它部分的参数，它不是立刻执行而是返回给你一个新的函数，这个新的函数接收剩下的参数，其内部则指向原始函数。当提供的参数完整了才会最终执行原始函数。
class Currying
{
// uncurried:普通函数
// 接收多个参数的函数（与类相关的函数，统称为方法，但是这里就直接说函数了，方便理解）
func add(a: Int, b: Int, c: Int) -> Int{
print("\(a) + \(b) + \(c)")
return a + b + c
}
/*下面更新2.2
// curried:柯里化函数
// 柯里化函数,Swift中已经支持这样的语法了，可以直接写
func addCur(a: Int)(b: Int)(c: Int) -> Int{
print("\(a) + \(b) + \(c)")
return a + b + c
}
*/
}
swift2.2 更新：
// curried:柯里化函数
// 柯里化函数,Swift中已经支持这样的语法了，可以直接写
func addCur(a: Int) -> Int ->( Int -> Int){
return {b in
{ c in
return a + b + c
}
}
}
Swfit中柯里化函数的定义：
func functionName(params)...(params) -> returnType{
......
}
柯里化函数实现原理：
class Currying
{
/*** uncurried:普通函数 ***/
// 接收多个参数的函数
func add(a: Int, b: Int, c: Int) -> Int{
print("\(a) + \(b) + \(c)")
return a + b + c
}
/*** 手动实现柯里化函数 ***/
// 把上面的函数转换为柯里化函数，首先转成接收第一个参数a，并且返回接收余下第一个参数b的新函数（采用闭包）
// 为了让大家都能看懂,我帮你们拆解来看下
// (a: Int) : 参数
// (b:Int) -> (c: Int) -> Int : 函数返回值（一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数)
// 定义一个接收参数a,并且返回一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
func add(a: Int) -> (b:Int) -> (c: Int) -> Int{
// 一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
return { (b:Int) -> (c: Int) -> Int in
// 返回一个接收余下第一个参数c，并且有返回结果为Int类型的函数
return { (c: Int) -> Int in
return a + b + c;
/*
注解： 这里为什么能使用参数a,b,c?
利用闭包的值捕获特性，即使这些值作用域不在了，也可以捕获到他们的值。
闭包会自动判断捕获的值是值拷贝还是值引用，如果修改了，就是值引用，否则值拷贝。
注意只有在闭包中才可以，a,b,c都在闭包中。
*/
}
}
}
/*更新2.2
/*** curried: 系统自带的柯里化函数 ***/
func addCur(a: Int)(b: Int)(c: Int) -> Int{
print("\(a) + \(b) + \(c)")
return a + b + c
}
*/
}
swift2.2 更新：
// curried:柯里化函数
// 柯里化函数,Swift中已经支持这样的语法了，可以直接写
func addCur(a: Int) -> Int ->( Int -> Int){
return {b in
{ c in
return a + b + c
}
}
}
调用柯里化函数：
// 创建柯里化类的实例
var curryInstance = Currying()
/*** 调用手动实现的柯里化函数 **/
var r: Int = curryInstance.add(10)(b: 20)(c: 30)
// 可能很多人都是第一次看这样的调用，感觉有点不可思议。
// 让我们回顾下OC创建对象 [[Person alloc] init]，这种写法应该都见过吧，就是一下发送了两个消息，alloc返回一个实例，再用实例调用init初始化,上面也是一样，一下调用多个函数，每次调用都会返回一个函数，然后再次调用这个返回的函数。
/***** 柯里化函数分解调用 *****/
// 让我来帮你们拆解下，更容易看懂
// curryInstance.add(10): 调用一个接收参数a,并且返回一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
// functionB: 一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
var functionB = curryInstance.add(10)
// functionB(b: 20):调用一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
// functionC: 一个接收参数c,返回值为Int类型的函数
var functionC = functionB(b: 20)
// functionC(c: 30): 调用一个接收参数c,返回值为Int类型的函数
// result: 函数的返回值
var res: Int = functionC(c: 30);
// 这里会有疑问?，为什么不是调用curryInstance.add(a: 10)，而是curryInstance.add(10),functionB(b: 20),functionC(c: 30),怎么就有b,c,这是因为func add(a: Int) -> (b:Int) -> (c: Int) -> Int这个方法中a是第一个参数，默认是没有外部参数名，只有余下的参数才有外部参数名,b,c都属于余下的参数。
/*更新swift2.2
/***** 系统的柯里化函数调用 *****/
var result: Int = curryInstance.addCur(10)(b: 20)(c: 30)
*/
/***** 系统的柯里化函数拆解调用 *****/
// 注意：Swift是强类型语言，这里没有报错，说明调用系统柯里化函数返回的类型和手动的functionB类型一致
// curryInstance.addCur(10) : 调用一个接收参数a,并且返回一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
// functionB: 一个接收参数b的函数,并且这个函数又返回一个接收参数c,返回值为Int类型的函数
functionB = curryInstance.addCur(10)
// functionC: 一个接收参数c,返回值为Int类型的函数
functionC = functionB(b: 20)
// result: 函数的返回值
res = functionC(c: 30)
// 打印 60，60，60说明手动实现的柯里化函数，和系统的一样。
print("\(r),\(res),\(result)")
swift2.2
var result: Int = curryInstance.addCur(10)(20)(30)
柯里化函数使用注意：
必须按照参数的定义顺序来调用柯里化函数,否则就会报错。
var result: Int = curryInstance.addCur(10)(b: 20)(c: 30)
swift2.2
var result: Int = curryInstance.addCur(10)(20)(30)
柯里化函数的函数体只会执行一次，只会在调用完最后一个参数的时候执行柯里化函数体。以下调用functionC(c: 30)才会执行函数体。这个可以自己断点调试
// curried:柯里化函数
func addCur(a: Int)(b: Int)(c: Int) -> Int{
print("\(a) + \(b) + \(c)")
return a + b + c
}
// 创建柯里化类的实例
var curryInstance = Currying()
// 不会执行柯里化函数体
functionB = curryInstance.addCur(10)
// 不会执行柯里化函数体
functionC = functionB(b: 20)
// 执行柯里化函数体
res = functionC(c: 30)
Swift中实例方法就是一个柯里化函数：
如何获取实例方法?可以直接通过类获取实例方法.
注意:方法是什么类型,就返回什么类型的函数，不过需要传入一个参数（类实例）才能获取到,如果方法中有外部参数名，外部参数名也属于类型的一部分
Swift中实例方法的另一种调用方式(柯里化调用)：
let add = Currying.addCur(cur) add(1)(b: 2)(c: 3) Currying.addCur(cur)(1)(b: 2)(c: 3)
柯里化函数有什么好处?为什么要使用它?
这里就需要了解函数式编程思想了，推荐看这篇文章函数式编程初探（http://www.ruanyifeng.com/blog/2012/04/functional_programming.html）
特点：
1.只用“表达式”(表达式:单纯的运算过程，总是有返回值)，不用“语句”(语句:执行某种操作，没有返回值)。2.不修改值，只返回新值。
好处：
1.代码简洁
2.提高代码复用性
3.代码管理方便，相互之间不依赖，每个函数都是一个独立的模块，很容易进行单元测试。
4.易于“并发编程”,因为不修改变量的值，都是返回新值。
柯里化函数就是运用了函数式编程思想，因此它也有以上的好处。
Swfit柯里化缺点：你不能简单的转换一般函数。如果能将任意接受多参数函数转换为柯里化函数，而 非创建一个新的函数那该是多好啊。另一个缺点是只能按定义的参数顺序来柯里化函数，这将不能让你执行反柯里化（比如只接受最后一个参数）或只提供你想提供 的参数。
在iOS开发中如何运用柯里化函数（实用性）
实用性一：复用性
需求1:地图类产品，很多界面都有相同的功能模块，比如搜索框。
我们可以利用柯里化函数，来组装界面，把界面分成一个个小模块，这样其他界面有相同的模块，直接运用模块代码，去重新组装下就好了。
实用性二：延迟性，柯里化函数代码需要前面的方法调用完成之后，才会来到柯里化函数代码中。
需求2:阅读类产品，一个界面的显示，依赖于数据，需要加载完数据之后，才能判断界面显示。
这时候也可以利用柯里化函数，来组装界面，把各个模块加载数据的方法抽出来，等全部加载完成，在去执行柯里化函数，柯里化函数主要实现界面的组装。
应用demo：
1
// 组合接口
// 为什么要定义接口，为了程序的扩展性，以后只需要在接口中添加对应的组合方法就好了。
protocol CombineUI
{
func combine(top: () -> ())(bottom: () -> ())()
}
// 定义一个界面类，遵守组合接口
class UI: CombineUI
{
func combine(top: () -> ())(bottom: () -> ())() {
// 搭建顶部
top()
// 搭建底部
bottom()
}
}
2
enum ControlEvent {
case TouchUpInside
case ValueChanged
// ...
}
class Control {
var actions = [ControlEvent: TargetAction]()
func setTarget<T: AnyObject>(target: T,
action: (T) -> () -> (), controlEvent: ControlEvent) {
actions[controlEvent] = TargetActionWrapper(
target: target, action: action)
}
func removeTargetForControlEvent(controlEvent: ControlEvent) {
actions[controlEvent] = nil
}
func performActionForControlEvent(controlEvent: ControlEvent) {
actions[controlEvent]?.performAction()
}
}
class MyViewController {
let button = Control()
func viewDidLoad() {
button.setTarget(self, action: MyViewController.onButtonTap, controlEvent: .TouchUpInside)
}
func onButtonTap() {
print("Button was tapped")
}
}
3、
func completionHandler(text: String) -> ([String]?, NSError?) -> () {
return {results, error in
self.results = results
self.resultLabel.text = text
self.tableView.reloadData()
}
}
func getAll() {
doGET("http://someurl.com/items?all=true", completionHandler("Got all items"))
}
func search(search: String) {
doGET("http://someurl.com/items?q=" + search, completionHandler("Got searched items"))
}
4、
/*
dispatch_async函数只接受不带参数的闭包作为参数，我们需要为它创建一个内部的闭包。但如果setResultLabelText是一个柯里化函数，我们能够将参数传递给它，然后获得一个不带参数的函数的引用，这样我们就能直接在dispatch_async函数中使用它了。
*/
func setResultLabelText(text: String)() { // now curried
resultLabel.text = text
}
dispatch_async(dispatch_get_main_queue(), setResultLabelText("Some text"))
/*
上面的代码看起来很不错，但你并不是总有权限去直接修改函数，比如当使用第三方库的时候。这种情况下你不能将原始函数转换为一个柯里化函数，或者你 已经在很多其他的地方用过这个函数，所以不好修改它。不过我们还是有办法的，通过创建一个新的函数并将其柯里化，我们能够达到类似的目的：
*/
// defined in global scope
func curry<T>(f: (T) -> (), arg: T)() {
f(arg)
}
//现在我们可以这么做：
func setResultLabelText(text: String) {
resultLabel.text = text
}
dispatch_async(dispatch_get_main_queue(), curry(setResultLabelText, "Some text"))
thx：
Swift中的函数柯里化(Function Currying)
《Swifter》
相关推荐
Swift中的函数柯里化，是一种将多参数函数转化为一系列单参数函数的过程，使得函数可以逐步接收参数，并在所有参数提供完整之前返回一个新函数。这种技术源于数学家哈斯凯尔·伽罗瓦（Haskell Curry）的名字，因此被...
“Swift 里可以将方法进行柯里化 (Currying)，这是也就是把接受多个参数的方法进行一些变形，使其更加灵活的方法。函数式的编程思想贯穿于 Swift 中，而函数的柯里化正是这门语言函数式特点的重要表现。 举个例子，...
书中还会涉及柯里化（Currying）、Monad等更高级的概念，这些都是函数式编程中的核心概念。 总之，通过对《函数式 Swift》的学习，开发者不仅可以深化对Swift语言的理解，还能提升编写高效、简洁和易于维护代码的...
- **移除柯里化（Currying）**: 柯里化是一种将多参数函数转换为嵌套单参数函数的技术，Swift 3 认为其过于复杂且不易理解，因此将其移除。 ##### 3. 枚举成员的命名改进 - **首字母小写**: 枚举成员的命名现在...
除此之外，书中还可能涵盖了其他函数式编程概念，如柯里化（Currying）、高阶函数（Higher-Order Functions）、尾递归（Tail Recursion）优化、闭包（Closures）的使用，以及如何通过函数式编程风格来实现常见的设计...
6. **柯里化（Currying）**：虽然Swift原生并不支持柯里化，但可以通过闭包实现。柯里化是将接受多个参数的函数转化为接受一个参数并返回另一个接受剩余参数的函数的过程，这样可以实现部分应用函数。 7. **函数...
2. **柯里化(Currying)**：柯里化是一种将接受多个参数的函数转换为一系列只接受一个参数的函数的技术。`FunctionKit` 支持柯里化，让开发者可以更容易地创建部分应用函数，提高代码复用性。 3. **函数组合...
柯里化(Currying)：将一个多参数函数转换成一系列单参数函数链。 使用map、filter、reduce等高阶函数处理集合。 枚举强化 利用关联值(associated values)增强枚举功能。 使用CaseIterable协议自动计算枚举的所有...
闭包的这种特性使其成为实现函数式编程概念如柯里化（Currying）和尾递归（Tail Recursion）的理想工具。柯里化允许我们将一个多参数的函数转换为一系列单参数函数，从而更容易进行组合和复用。尾递归优化则是Swift...
14. **函数柯里化（Currying）**：虽然Swift并不直接支持柯里化，但可以通过闭包实现类似功能，创建多参数函数的单参数版本。 15. **元组（Tuples）**：元组用于组合多个值，可以在函数返回多种类型的数据或临时...
6. **柯里化(Currying)**：这是一种将多参数函数转换为一系列单参数函数的技术。在Swift中，可以通过闭包实现柯里化，使函数更易于复用和组合。 7. **函数组合(Composition)**：函数组合允许将多个函数串联起来形成...
文档还介绍了Swift的“柯里化”（currying）概念。柯里化是将接受多个参数的函数转换为一系列使用一个参数的函数的方法，是函数式编程的一个重要概念。在Swift中，柯里化被用于方法和构造器的实现，这种机制导致闭包...
Swift 里可以将方法进行柯里化 (Currying)，这是也就是把接受多个参数的方法进行一些变形，使其更加灵活的方法。函数式的编程思想贯穿于 Swift 中，而函数的柯里化正是这门语言函数式特点的重要表现。 举个例子，...
1. **柯里化 (Currying)** - 柯里化是一种将多参数函数转换为一系列单参数函数的技术。 - 例如，一个接受两个参数 `a` 和 `b` 的函数可以被转化为一个接受参数 `a` 的函数，该函数返回一个接受参数 `b` 的函数。 ...
Currying（柯里化） 柯里化是一种将接受多个参数的函数转化为一系列接受单个参数的函数的技术。Swift中虽然没有直接支持柯里化，但可以通过闭包实现类似效果。 ```swift func curryFunction(a: Int)(b: Int) -> ...
#### 1.1 柯里化 (Currying) 柯里化是一种将多参数函数转换为一系列单参数函数的技术。在 Swift 中可以通过返回闭包的方式来实现。例如： ```swift func add(a: Int, b: Int) -> Int { return a + b } let ...
5. **柯里化（Currying）**：柯里化是将接受多个参数的函数转换为一系列只接受一个参数的函数的过程。Swift虽然没有内置的柯里化支持，但可以通过闭包实现： ```swift func curry, B, C>(_ f: @escaping (A, B) -> C...