Swift 柯里化

Posted qianchia

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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

以上是关于Swift 柯里化的主要内容,如果未能解决你的问题,请参考以下文章

Swift柯里化

Swift柯里化

Swift函数柯里化(Currying)简谈

柯里化与反柯里化

函数柯里化

手写柯里化,实现柯里化