MENU

Swift中的柯里化Currying

Swift 中的柯里化 Currying

在上一篇文章中,我们使用到了 "Curry"。如果你看了这个框架的源代码的话,可能有点犯晕(有可能只有我一个人这样,大家都是大神)。这篇文章就是关于这个“柯里化”的内容,参考了库作者的博客以及喵神的 tips 和 Ole Begemann 的文章。顺便说一句喵神出书,可以去支持一下。

什么是柯里化 (Currying)

首先,我们来看个简单的例子:

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

这个函数很容易理解,就是一个整型求和的函数,函数接收两个整型作为参数,并返回两个参数相加的结果。我们可以直接使用该函数:

let sum = add(2)(3) //sum = 5  

当我们希望将一个整数数组里面的所有数据都增加一个基数的时候,我们可以进行如下的操作:

let xs = 1...10  
let x = xs.map {
    return add($0,b: 2)
}  
// x = [3,4,5,etc]  

在代码中,我们先声明并初始化了一个整型数组,然后用 map 方法是数组里面的元素都增加了2,并将结果保存到新的数组中。其中 $0 表示当前迭代到的元素。在代码中,我们使用了闭包(closure),并且传递了一个默认参数。但是当在多处使用类似功能的时候,每次都写闭包还是不够精简。下面做第一步改进:

func addTwo(a: Int) -> Int {
     return add(a, 2)
}
    
let xs = 1...10
let x = xs.map(addTwo)  
// x = [3,4,5,etc]  

但是这个改进有明细的不足,就是默认参数是写死的。当我们要将默认参数设为3的时候我们不得重新写一个函数 addThree ,这显然不符合代码复用的要求。我们进一步做出修改:

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

这个函数看起来是不是有点晕啊。我们来一步步分析一下这个函数,首先,函数接收一个整型参数 a ,函数的返回值是一个 Int -> Int 的函数类型,在这个返回的函数类型也会传入一个参数,以及返回一个值(参数 a 是函数 add 传入,参数 b 是闭包里的,返回值是 a + b ),这意味这两件事:

  1. 如果我们直接调用该函数的化,我们需要使用两个括号来区分这两个参数,形如:

let sum = add(2)(3) //sum = 5  
  1. 我们可以通过传递一个参数个该函数,那么他会返回一个接收一个参数的新函数。如果我们再传入一个参数给这个返回的无名函数,那么就会返回一个我们想要的结果:

let addTwo = add(2)
let xs = 1...100
let x = xs.map(addTwo) // x = [3, 4, 5, 6, etc]  

上面的柯里化函数的另外一种更容易理解的形式是:

func add(a: Int)(num: Int) -> Int {
     return a + num
}

直接调用的形式与上面略有不同:

let sum = add(2)(num: 3) // sum = 5 

综上,我们可以将柯里化的进行如下描述:

柯里化就是将一个接收多参数的函数,改造为接收第一个参数,然后返回一个接收余下参数的新方法。柯里化最大的一个好处就是代码复用便于维护,以及量产类似的方法。

//批量产生类似方法:    
let addTwo = add(2)
let addThree = add(3)
let addFour = add(4)

进一步理解柯里化(Currying)

我们看看下面的简单实例:

class BankAccount {
    var balance: Double = 0.0

    func deposit(amount: Double) {
         balance += amount
    }
}

我们最常见的用法:

let account = BankAccount()
account.deposit(100)  // balance is now 100

下面看一个非常规的用法:

let depositor = BankAccount.deposit
depositor(account)(100)  // balance is now 200

我们看见下面的操作实现的效果于上面的那个是一样的。让我们来分析一下这个非常规的操作。首先,第一步将函数 deposit 函数赋值给变量 depositor,我们可以看见 BankAccount.deposit 后面并没有常见的括号。此时的 depositor 其实是一个 BankAccount -> (Double) -> () 类型的实例,有点类似于C中的函数指针。可以在playground右侧看见类型信息,见下图。

playground类型显示

BankAccount.deposit() 传入参数 account 其实就是实现绑定。

也就是说 depositor 传入一个 BankAccount 类实例作为参数会返回一个 Double -> () 类型的函数,再传入一个参数就可以实现变量的叠加了。上面的非常规做法可以进一步简化:

BankAccount.deposit(account)(100) //balance is now 300  

到目前为止,我们只是对一些自己的函数或者自定义类的函数上应用了柯里化,那么如何在系统或者第三方库中应用这种有益的特性呢?我们看下面的例子,主要用到了拓展和泛型。

extension NSNumber {
    class func multiple(left: Int, right:Int) -> Int {
          return left * right
    }
}

func curry(function: (Int,Int) -> Int) -> (Int -> (Int -> Int)){
       return { a in
            { b in
              return function(a,b)
          }
     }
}

首先我们拓展了NSNumber,定义了一个整型的乘法运算函数。然后y又定义了一个curry函数,该函数看起来非常复杂,我们来一步步来分析。首先curry函数接受一个函数类型的参数类型为 (Int,Int) -> Int ,然后会返回一个函数类型 Int -> (Int -> Int) ,然后再传入一个整型给该返回类型,回继续返回一个 Int -> Int 函数类型,再传入参数才会得到最会结果。接下来看函数内部,return 语句首先返回了一个闭包,该闭包就是 Int -> (Int -> Int) 类型:

{ a in 
   //....
}  

再看下一层闭包,类型是 (Int -> Int),在最内层的闭包中会将上两层闭包传入的参数 a、b 进行 function 操作。但是这并不是最通用的做法,还能改进。可以使用泛型的特征使 curry 函数不受参数类型限制。具体实现:

extension NSNumber {
    class func multiple(left: Int, right:Int) -> Int {
          return left * right
      }
    
    class func add(left:Double, right:Double) -> Double {
          return left + right
    }
        
}  
    
func curry<A, B, C>(function: (A,B) -> C) -> (A -> (B -> C)){
       return { a in
            { b in
                return function(a,b)
             }
     }
} 

curry(NSNumber.multiple)(2)(3)      // 6
curry(NSNumber.add)(2.0)(3.0)       // 5.0

具体的类型可以在 playground 右侧查看。

熟悉了解柯里化的特性后,以后就可以自己写个高复用的类库了,当然也可以使用上篇文章中提到的 Curry 类库

标签: Swift