currying 是函数式语言中经常遇到的一个概念,翻译成 柯里化,不是库里化。
currying 指的是将接收多个参数的函数变换成接收一个单一参数,并且返回接收余下的参数而且返回结果的新函数的技术。
说起来比较拗口,直接看下面的代码。
defadd(x: Int, y: Int): Int = x + y //call add add(1, 2) add(3, 4)
但是如果我们使用 currying 的写法,那么可以将两个参数分开,接收第一个参数(x),然后返回一个函数,这个函数以第二个参数(y)为参数,返回结果:
defadd(x:Int) => (y: Int) = x + y
然后我们就可以这样调用 add 了。
add(1)(2) add(3)(4)
scala 对于这种写法提供了语法糖,add 的 currying 写法我们可以更简单地写为:
defadd(x: Int)(y: Int): Int = x + y
尝试将一个函数(这里指f)写成 curry 方式:
def curry[A, B, C](f: (A, B) => C): A => (B => C) = a => b => f(a, b)
这里的 currying 函数,它接收两个参数,分别为 A 类型和 B 类型,然后返回一个 C 类型的结果。那么我们可以通过得到一个偏函数将其转化为 curry 的方式,即 A => (B => C)。具体流程是,用第一个参数 a ,得到一个函数,这个函数使用 b 作为参数,然后得到结果。这里中间的这个函数,是一个偏函数。
同样我们也可以写一个 uncurry 的方法(即将 currying 的函数f转化成非 currying 的):
def uncurry[A, B, C](f: A => B => C): (A, B) => C = (a, b) => f(a)(b)
这里在 currying 的过程中,使用了偏函数(partial applied function),偏函数是什么?这个其实更好理解一些,通俗的讲,可以理解为定制化函数,比如我们有一个函数需要两个参数,那么如果我们返回固定其中一个参数的函数,那么我们就得到了一个偏函数:
defadd(x: Int, y: Int): Int = x + y defadd1(y: Int): Int = add(1, y)
这里我们就是固定了 add 函数中的 x 参数,然后返回了另外一个函数 add1,现在 add1 只有一个参数,我们直接可以调用 add1:
add1(5) //6
可以看到,currying 和偏函数的主要区别就是,是否固定了参数,偏函数一旦固定参数之后,就返回了新的函数。而 currying 一般并没有固定参数,只是类似于使用了黑魔法,让多个参数的函数,最后变成了一个函数链。
其实在 C 语言中也有偏函数这种用法:
int foo(int a, int b, int c) { return a + b + c; } int foo23(int a, int c) { return foo(a, 23, c); }
但是在函数式语言中,偏函数以及 currying 能发挥更大的作用,原因是,函数式中,我们的参数还可以是函数。
defsum(f: Int => Int, a: Int, b: Int): Int = if(a > b) 0 else f(a) + sum(a+1, b)
这里有一个 sum 函数,它将 a 和 b 之间的所有的数,用 f 计算之后相加,比如:
sum(x => x * x, 1, 10)
那么就是计算 1 到 10 之间所有数的平方和。但是如果我们要计算所有数的立方和呢,四次方呢?
固然我们可以将 f 传递成不同的值,但是我们也可以更简单地直接得到定制化之后的函数,即用不同的 f 得到不同的函数。
为了达到我们的目的,我们将函数写成 currying 形式:
defsum(f: Int => Int)(a: Int, b: Int): Int = if(a >b) 0 else f(a) + sum(f)(a+1, b)
这个时候 sum 函数的类型是什么呢?是:(Int => Int) => (( Int, Int) => Int)。第一层函数是一个参数类型为 Int => Int 的函数,其返回是一个函数,这个函数以 (Int, Int) => Int 类型为返回值。因此,如果我们传递不同的第一层函数的参数,即 Int => Int,那么就将得到不同的第二层函数,即类型为 (Int, Int) => Int 的函数。
因此,我们可以传入不同的 f,传入 f 之后,得到的函数就是以 a 和 b 为参数的函数:
为此我们将 sumT 函数定义成如下形式,使得 sumT 函数返回一个类型为 (Int, Int) => Int 的函数:
defsumT(f: Int => Int): (Int, Int) => Int = { defsumF(a: Int, b: Int): Int = if(a > b) 0 else f(a) + sumF(a+1, b) sumF }
然后我们就可以传递不同的 f,获取不同的偏函数:
def sum3 = sum(x => x * x * x) //三次方 def sum4 = sum(x => x * x * x * x) //四次方
这里可以看出,偏函数和 currying 是有很大的关联的。函数 currying 后,很容易实现某些偏函数。
在 scala 中,如果需要减少函数的参数,即固定函数的某些参数,那么使用偏函数即可。那么,currying的作用是什么?
作用有二,一个是可以将函数的参数写成{}形式,这对于参数是函数时可读性更好。
在currying之前,可能需要这样写:
using (new File(name), f => {......})
在有了 currying 之后,我们可以写成更易读的方式:
using(new File(name)){ f => ......}
第二个作用就是用于类型推导:
一般的 currying 可以写成
deff(arg1)(arg2)......(argn) => E //等同于 deff(arg1)(arg2)......(argn-1) => { defg(argn) => E; g} /.更简单点 deff(arg1)(arg2)......(argn-1) => (argsn => E) //继续最后就可以写成 def f = args1 => args2......=>argsn => E
这样写之后,scala 可以对参数之间的类型进行推导:左边参数的类型可以用于推导右边参数的类型,从而某些参数就可以简化写法:
def dropWhile[A](as: List[A], f: A => Boolean): List[A] = ...... //调用 dropWhile(List(1,2,3,4), (x: Int => x < 4)) //currying之后 dropWhile[A](as:List[A])(f: A => Boolean): List[A] = ...... //调用 dropWhile(List(1,2,3,4))(x => x < 4) //这里不再需要指明 x 的类型
这样就可以用来结合匿名函数的下划线写出更加简洁的代码。
currying 也可以在某些只允许使用单个参数的函数的情景下发挥作用,利用 currying 使用层层嵌套的单参数函数,可以实现语法层面的多参数函数。
本文永久更新链接地址 : http://www.linuxidc.com/Linux/2016-12/138371.htm