Swift柯里化(Currying)

什么是柯里化函数:

柯里化(英语: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)

【Swift之柯里化函数(精品)】| 那些人追的干货

函数式编程初探

《Swifter》

相关推荐