函数式编程之foldLeftViaFoldRight
问题来自 Scala 函数式编程 一书的习题, 让我很困扰, 感觉函数式编程有点神学的感觉.后面看懂之后, 又觉得函数式编程所提供的高阶抽象是多么的强大. 这个问题让我发呆了好久, 现在把自己形成的想法分享下, 如果能少让一个人为这个问题烦恼, 那就再好不过了:)
问题: 如何通过函数 foldRight 实现 左折叠(left fold)操作 ?
这里只是讨论理论上的可行性, 实际中都是通过函数 foldLeft 实现右折叠操作,
因为函数 foldLeft 是栈安全的(不会因为压栈太深导致栈溢出).
答案:
def foldLeftViaFoldRight[A,B](l: List[A], z: B)(f: (B,A) => B): B = {
foldRight(l, (b: B) => b)((a, g) => b => g(f(b, a)))(z)
}
那么下面我们来一步步解析这个答案:)
左折叠 与 右折叠
我们先看一下函数 foldRight 和 foldLeft 的定义:
def foldRight[A, B](l: List[A], b: B)(f: (A, B) => B):B = l match {
case Nil => z
case h::t => f(h, foldRight(t, b)(f))
}
@annotation.tailrec
def foldLeft[A, B](as: List[A], z: B)(f: (B, A) => B):B = as match {
case Nil => z
case h::t => foldLeft(t, f(z, h))(f)
}
让我们看看一个列表L List(1, 2, 3) 左折叠和右折叠操作(foldRight) 的运行过程:
// 左折叠
f(3, f(2, f(1, b)))
// 右折叠
f(1, f(2, f(3, b)))
从上面可以看到
- 左折叠操作, 初始值
b先和列表最左边的元素进行f的运算, 从左往右依次计算. - 右折叠操作, 初始值
b先和列表最右边的元素进行f的运算, 从右往左依次计算.
再来看一个例子就更加清楚了
println(foldLeft(List(1,2,3), 0)((a, b) => { println(a, b); b + a}))
println(foldRight(List(1,2,3), 0)((a, b) => { println (a, b); b + a }))
/* output
(1, 0)
(2, 1)
(3, 3)
6
(3, 0)
(2, 3)
(1, 5)
6
*/
复合函数
首先看看什么是复合函数? 下面是百度百科的定义
设函数y=f(u[x])的定义域为 Du，值域为 Mu，函数 u=g(x) 的定义域为 Dx，值域为 Mx，
如果 Mx∩Du≠Ø，那么对于 Mx∩Du 内的任意一个x经过u；有唯一确定的y值与之对应，则变量x与y之间通过变量u形成的一种函数关系，这种函数称为复合函数(composite function)，记为：y=f[g(x)]，其中x称为自变量，u为中间变量，y为因变量（即函数）。
不是任何两个函数都可以复合成一个复合函数，只有当Mx∩Du≠Ø时，二者才可以构成一个复合函数。
让我们创建两个函数：
scala> def f(s: String) = "f(" + s + ")"
f: (String)java.lang.String
scala> def g(s: String) = "g(" + s + ")"
g: (String)java.lang.String
compose
compose 组合其他函数形成一个新的函数 f(g(x))
scala> val fComposeG = f _ compose g _
fComposeG: (String) => java.lang.String = <function>
scala> fComposeG("hello")
res0: java.lang.String = f(g(hello))
andThen
andThen 和 compose很像，但是调用顺序是先调用第一个函数，然后调用第二个，即g(f(x))
scala> val fAndThenG = f _ andThen g _
fAndThenG: (String) => java.lang.String = <function>
scala> fAndThenG("hello")
res1: java.lang.String = g(f(hello))
关键一步
这里把解决方法再贴出来, 方便对照
def foldLeftViaFoldRight[A,B](l: List[A], z: B)(f: (B,A) => B): B =
foldRight(l, (b:B) => b)((a, g) => b => g(f(b, a)))(z)
将 匿名函数 ((a, g) => b => g(f(b, a))) 改写为
def h(a: A, g: B => B): (B => B) =
g compose ((x: B) => f(x, a));
怎么想?
通过上面函数的定义, 我们可以把解决方法写成
def foldLeftViaFoldRight_2[A,B](l: List[A], z: B)(f: (B,A) => B): B = {
def h(a: A, g: B => B): (B => B) = g compose ((x: B) => f(x, a))
def identity(b: B) = b // 恒等函数
foldRight(l, identity _)(h _)(z)
}
我们想通过函数 foldRight 实现 foldLeft, 而foldRight 从右边处理列表元素, 而我们想从左边处理列表元素.
以列表 List(1, 2, 3)为例,
由 右折叠的定义, 计算过程为:
// 右折叠
h(1, h(2, h(3, identity)))
而我们想要实现左折叠操作, 即函数的最终运行结果应该是
f(f(f(1, z), 2), 3)
这里的技巧就在于函数 g 的类型为 B => B, 函数 h 类型也是 B => B,函数 identity 的类型为 B => B; 这样就能进行组成一条符合函数链;
然后我们通过复合函数链完成上述的思路.
有一点在这很重要, 那就是, g 和 h 都是高阶抽象函数, 你可能很想知道函数 g 的具体实现是什么, 其实这是不必要的也是错误的想法;
我们不要在意 g 具体实现是什么, 那么我们要关注什么呢?
那就是函数 g, h, identity 类型为 B => B, 一个例子就能让你清楚的明白上面再说什么了, 你也能看出来函数 g 其实并不是一个具体的函数, 它随着计算阶段也在不停的变动, 这就是理解的难点所在
例子
现在让我们看一下当我们传递列表 List(1, 2)时, 发生了什么：
val l = List(1, 2)
foldRight(l, identity[B] _)(h _)
= h(1, h(2, identity([B]))) // 由 右折叠 的定义可知
= h(1, identity[B] compose ((x: B) => f(x, 2))) // 展开里面的 `h`
// 由于 identity[B] 是恒等函数,
// identity[B] compose ((x: B) => f(x, 2)) =
// identity(((x: B) => f(x, 2))) = ((x: B) => f(x, 2))
= h(1, ((x: B) => f(x, 2)))
// 展开另一个 'h'
= ((x: B) => f(x, 2)) compose ((x: B) => f(x, 1))
// 由 function composition 定义可知 f1 _ compose f2 = f1(f2)
= (x: B) => f(f(x, 1), 2) // 左折叠操作
看看上面的过程, 我们实现了转换:
h(1, h(2, identity([B]))) => f(f(x, 1), 2)
即通过右折叠函数 foldRight 实现了左折叠操作
这里函数 g 先后是,
- identity([B])
- ((x: B) => f(x, 2))
正是函数类型为 "B => B" 进行复合的技巧所在
并且我们看到, 对于列表的每一元素 a, 都会建立一个 包含函数 g 的函数 h, 并且每个新的函数h的都是前一个函数 h 的输入。
一点思考
1. 关于函数 identity 是如何得来的 ?
如果列表 l 是空列表, 那么 foldLeftViaFoldRight 应该返回 z,
所以函数 h 应该是一个恒等函数, 所以我们将恒等函数作为第二个参数传递给 foldRight.
2. 这里通过建立一条复合函数链, 通过利用函数压栈中, 栈的先进后出特性实现了计算顺序的翻转; 所以方法是非栈安全的, 数据太大有栈溢出的风险, 这里只是说明理论的可行xing
