Swift 柯里化

前言

  • 由于柯里化在业务层的应用较少，所以从 Swift 3.0 开始移除了柯里化的用法，但是 Swift 的很多底层特性是使用柯里化来表达的。

1、柯里化

1.1 柯里化简介

  • 柯里化（Currying），又称部分求值（Partial Evaluation），是一种函数式编程思想，就是把接受多个参数的函数转换成接收一个单一参数（最初函数的第一个参数）的函数，并且返回一个接受余下参数的新函数技术。

  • uncurried: 普通函数

    // 接收多个参数的函数（与类相关的函数，统称为方法，但是这里就直接说函数了，方便理解）
func add(a: Int, b: Int, c: Int) -> Int {

    print("(a) + (b) + (c)")
    return a + b + c
}

  • curried: 柯里化函数

    // 柯里化函数，Swift 3.0 之前支持这样的语法，可以直接写
func addCur(a: Int)(b: Int)(c: Int) -> Int {

    println("(a) + (b) + (c)")
    return a + b + c
}

1.2 如何定义柯里化函数

  • 定义柯里化函数

    func function name (parameters)(parameters) -> return type {

    statements
}

1.3 柯里化函数实现原理

  • uncurried: 普通函数

    class Currying {

    // 接收多个参数的函数
    func add(a: Int, b: Int, c: Int) -> Int {

        print("(a) + (b) + (c)")
        return a + b + c
    }
}

  • 系统自带的柯里化函数

    class Currying {

    func addCur(a: Int)(b: Int)(c: Int) -> Int {

        print("(a) + (b) + (c)")
        return a + b + c
    }
}

  • 手动实现柯里化函数

    • 把上面的函数转换为柯里化函数，首先转成接收第一个参数 a，并且返回接收余下第一个参数 b 的新函数（采用闭包）.

    • 这里为什么能使用参数 a、b、c ?

      • 利用闭包的值捕获特性，即使这些值作用域不在了，也可以捕获到他们的值。
      • 闭包会自动判断捕获的值是值拷贝还是值引用，如果修改了，就是值引用，否则值拷贝。
      • 注意只有在闭包中才可以，a、b、c 都在闭包中。
      class Currying {

    // (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;
            }
        }
    }
}

1.4 如何调用柯里化函数

  • 创建柯里化类的实例

    var curryInstance = Currying()

  • 手动实现的柯里化函数调用

    var result: Int = curryInstance.add(a: 10)(b: 20)(c: 30)
    • 可能很多人都是第一次看这样的调用，感觉有点不可思议。
    • 让我们回顾下 OC 创建对象 [[Person alloc] init]，这种写法应该都见过吧，就是一下发送了两个消息，alloc 返回一个实例，再用实例调用 init 初始化，上面也是一样，一下调用多个函数，每次调用都会返回一个函数，然后再次调用这个返回的函数。

  • 手动实现的柯里化函数拆解调用

    • curryInstance.add(a: 10) 调用一个接收参数 a，并且返回一个接收参数 b 的函数，并且这个函数又返回一个接收参数 c，返回值为 Int 类型的函数。

      // functionB: 一个接收参数 b 的函数，并且这个函数又返回一个接收参数 c，返回值为 Int 类型的函数
let functionB = curryInstance.add(a: 10)

    • functionB(b: 20) 调用一个接收参数 b 的函数，并且这个函数又返回一个接收参数 c，返回值为 Int 类型的函数。

      // functionC: 一个接收参数 c，返回值为 Int 类型的函数
let functionC = functionB(b: 20)

    • functionC(c: 30) 调用一个接收参数 c，返回值为 Int 类型的函数。

      // result: 函数的返回值
var result: Int = functionC(c: 30);

  • 系统的柯里化函数调用

    var result: Int = curryInstance.addCur(a: 10)(b: 20)(c: 30)

  • 系统的柯里化函数拆解调用

    • curryInstance.addCur(a: 10) 调用一个接收参数 a，并且返回一个接收参数 b 的函数，并且这个函数又返回一个接收参数 c，返回值为 Int 类型的函数。

      // Swift是强类型语言，这里没有报错，说明调用系统柯里化函数返回的类型和手动的 functionB 类型一致
// functionB: 一个接收参数 b 的函数，并且这个函数又返回一个接收参数 c，返回值为 Int 类型的函数
functionB = curryInstance.addCur(a: 10)

    • functionB(b: 20) 调用一个接收参数 b 的函数，并且这个函数又返回一个接收参数 c，返回值为 Int 类型的函数。

      // functionC: 一个接收参数c,返回值为Int类型的函数
functionC = functionB(b: 20)

    • functionC(c: 30) 调用一个接收参数 c，返回值为 Int 类型的函数。

      // result: 函数的返回值
result = functionC(c: 30)

// 打印 60，60，60 说明手动实现的柯里化函数，和系统的一样。
print("(r), (res), (result)")

1.5 柯里化函数使用注意

  • 必须按照参数的定义顺序来调用柯里化函数，否则就会报错。

  • 柯里化函数的函数体只会执行一次，只会在调用完最后一个参数的时候执行柯里化函数体。

    • 以下调用 functionC(c: 30) 才会执行函数体，这个可以自己断点调试。

      // curried: 柯里化函数
func addCur(a: Int)(b: Int)(c: Int) -> Int {

    println("(a) + (b) + (c)")
    return a + b + c
}

// 创建柯里化类的实例
var curryInstance = Currying()

// 不会执行柯里化函数体
functionB = curryInstance.addCur(a: 10)

// 不会执行柯里化函数体
functionC = functionB(b: 20)

// 执行柯里化函数体
result = functionC(c: 30)

1.6 柯里化函数的好处

  • 这里就需要了解函数式编程思想了，柯里化函数就是运用了函数式编程思想，推荐看这篇文章函数式编程初探。

  • 特点

    • 1）只用 “表达式” (表达式: 单纯的运算过程，总是有返回值)，不用 “语句” (语句: 执行某种操作，没有返回值)。
    • 2）不修改值，只返回新值。

  • 好处

    • 1）代码简洁。
    • 2）提高代码复用性。
    • 3）代码管理方便，相互之间不依赖，每个函数都是一个独立的模块，很容易进行单元测试。
    • 4）易于 “并发编程”，因为不修改变量的值，都是返回新值。

1.7 柯里化函数的实用性

  • 实用性一：复用性

    • 需求 1：地图类产品，很多界面都有相同的功能模块，比如搜索框。

      • 我们可以利用柯里化函数，来组装界面，把界面分成一个个小模块，这样其他界面有相同的模块，直接运用模块代码，去重新组装下就好了。

  • 实用性二：延迟性

    • 柯里化函数代码需要前面的方法调用完成之后，才会来到柯里化函数代码中。

    • 需求 2：阅读类产品，一个界面的显示，依赖于数据，需要加载完数据之后，才能判断界面显示。

      • 这时候也可以利用柯里化函数，来组装界面，把各个模块加载数据的方法抽出来，等全部加载完成，再去执行柯里化函数，柯里化函数主要实现界面的组装。

  • 举例说明

    // 组合接口
// 为什么要定义接口，为了程序的扩展性，以后只需要在接口中添加对应的组合方法就好了。
protocol CombineUI {

    func combine(top: () -> ())(bottom: () -> ())()
}

// 定义一个界面类，遵守组合接口
class UI: CombineUI {

    func combine(top: () -> ())(bottom: () -> ())() {
    
        // 搭建顶部
        top()
        
        // 搭建底部
        bottom()
    }
}

2、Swift 中实例方法的柯里化

  • Swift 中实例方法就是一个柯里化函数。

2.1 Swift 中实例方法的柯里化调用

  • Swift 中实例方法的柯里化调用

    • 示例结构体

      struct Example {

    var internalStr = ""

    func combine(externalStr: String) {
        print(internalStr + " " + externalStr)
    }
}

    • 调用实例方法的常用格式

      let example = Example(internalStr: "hello")

example.combine(externalStr: "word")            // hello word

    • 调用实例方法的柯里化格式

      let example = Example(internalStr: "hello")

Example.combine(example)(externalStr: "word")   // hello word
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/QianChia/p/8876174.html