转载

函数式中的 currying

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

原文  http://www.linuxidc.com/Linux/2016-12/138371.htm
正文到此结束
Loading...