用纯函数式思维在Java8下写的一段奇葩程序
首先说一下什么是纯函数式。在我的理解,“纯函数式”用一句话就可以描述:Anything is value.——我的理解不一定准确,但我就是这么理解的。
就是所有的东西都是值——没有变量;包括函数在内都是值——是值,就可以传递(包括函数)。
为什么说这段程序是奇葩呢?
其一、传统的Java是面向对象的,自从Java8中加入了lambda,Java就变成了“面向对象”和“函数式”两种方式的混合语言。这段程序全部使用lambda的语法来写,与平常写的Java风格完全不同。
其二、在Java的对象中保存数据通常是用对象的属性,lambda表达式本质上仍然是对象,但它并没有属性,但我们却成功的在lambda中保存了数据,这相对于传统的Java编程思维也是一种跳跃。
其三、在Scheme中实现同样的函数(或lambda)非常简洁,也很容易读,而在Java中的实现,可读性好差,以致于我自己都快看不懂了,所以说是“奇葩”。
这段程序用两种方式实现了同样的功能:
1.实现一个函数cons,这个函数有两个参数x和y,并返回一个东西(这个东西以下简称为c)。
2.实现一个函数car,传入c,并返回原来传入cons中的x。
3.实现一个函数cdr,传入c,并返回原来传入cons中的y。
这实际上是Scheme中自带的“序偶”,不过即使Scheme语言本身的库不自带cons,我们自己实现也是很简单的(下面的程序中,我在注释部分列出了Scheme的实现);Java骨子里是面向对象的基因,如果用面向对象的方式来实现上述功能是非常简单的,但用lambda的语法来实现就显得奇葩了。
下面先把奇葩贴出来,然后在后面的注释中解释一下:
import java.util.function.BiFunction;
import java.util.function.Function;
public class TestCons {
public static void main(String[] args) {
testCons1();
testCons2();
}
private static void testCons1() {
/*
(define (cons x y)
(lambda (m)
(cond ((= m 0) x)
(else y))))
(define (car z) (z 0))
(define (cdr z) (z 1))
上面几行Scheme代码翻译成Java是如下三行代码
*/
BiFunction<Object, Object, Function<Integer, Object>> cons = (x, y) -> m -> m == 0 ? x : y; // 注释1
Function<Function, Object> car = z -> z.apply(0); // 注释2
Function<Function, Object> cdr = z -> z.apply(1); // 注释3
Function c = cons.apply(3, "abc"); // 调用cons,并传入两个值,创建了对象c
System.out.println(car.apply(c)); // 从c中取出第一个值
System.out.println(cdr.apply(c)); // 从c中取出第二个值
}
private static void testCons2() {
/*
(define (cons x y)
(lambda (m) (m x y)))
(define (car z)
(z (lambda (p q) p)))
(define (cdr z)
(z (lambda (p q) q)))
上面几行Scheme代码翻译成Java是如下三行代码
*/
BiFunction<Object, Object, Function<BiFunction, Object>> cons = (x, y) -> f -> f.apply(x, y); // 注释4
Function<Function<BiFunction, Object>, Object> car = f -> f.apply((a, b) -> a); // 注释5
Function<Function<BiFunction, Object>, Object> cdr = f -> f.apply((a, b) -> b); // 注释6
Function c = cons.apply(3, "abc"); // 调用cons,并传入两个值,创建了对象c
System.out.println(car.apply(c)); // 从c中取出第一个值
System.out.println(cdr.apply(c)); // 从c中取出第二个值
}
}
注释1:此行创建一个叫cons的lambda表达式,此表达式有两个参数x和y,并返回另外一个lambda,这个lambda有一个整数类型的参数m,且当m为0时,返回x,否则返回y。
注释2:此行创建一个叫car的lambda,此lambda有一个参数,且这个参数也是一个lambda(z),car的lambda体中是把0传入z中,并得到返回值。
结合“注释1”和“注释2”这两行,我们可以这样解释:cons返回的lambda可以做为car的参数。
注释3:和“注释2”差不多,不再缀述。
注释4:此行创建一个叫cons的lambda,此lambda有两个参数x和y,反返回另外一个lambda,这个lambda有一个参数,且这个参数也是一个lambda(f),在cons返回值的lambda体中应用f,并把cons的两个参数做为f的两个参数——相当拗口——简单点说就是cons并不做什么,只是把x和y,交给一个lambda,而这个lambda也不做什么,只是等着另外一个lambda(f)来处理x和y,而这个f要通过参数传过来。
注释5:此行创建一个小car的lambda,此lambda有一个参数(此参数可传入cons返回的lambda),从“注释4”中我们知道cons返回的lambda还需要一个lambda做为参数来处理两个参数,所以我们传入一个(a, b) –> a,这里在a和b中返回前者,这就是car的目的。
注释6:和“注释5”差不多,不再缀述。
到处都是lambda,很难读,但在Scheme中完全一样的算法实现就很简洁,可读性很好,这是为什么呢?
我认为这是S表达式的语法结构形成的效果——S表达式是以数据结构的方式存储程序的,这样的情况下,假设Scheme中没有lambda,此时我们要扩展编译器来支持lambda,则我们不需要修改编译器的parser部分——但Java的lambda没有办法与现有的其它语法的结构一样,所以就只能新增新的语法结构了,但又要与原有的基因融合,这样虽然lambda在本质上仍然是对象,但在表现形式上与原有的Java却有很大的排异反应。
这不是一两句话能说得明白的,也有点扯远了。
下面再演示一个邱奇计数的例子,这个就不写注释了:
import java.util.function.Function;
public class testChurchNum {
public static void main(String[] args) {
Function<Function<Function<Object, Object>, Function>, Function<Function<Object, Object>, Function>>
add_1 = n -> f -> x -> f.apply(n.apply(f).apply(x));
Function<Function<Object, Object>, Function> zero = f -> x -> x;
Function<Function<Object, Object>, Function> one = add_1.apply(zero);
Function<Function<Object, Object>, Function> tow = add_1.apply(one);
Function<Function<Object, Object>, Function> one_1 = f -> x -> f.apply(x);
Function<Function<Object, Object>, Function> tow_1 = f -> x -> f.apply(f.apply(x));
Function f = x -> (((Integer) x) + 1);
System.out.println(zero.apply(f).apply(0));
System.out.println(one.apply(f).apply(0));
System.out.println(one_1.apply(f).apply(0));
System.out.println(tow.apply(f).apply(0));
System.out.println(tow_1.apply(f).apply(0));
}
}
周游[http://www.cnblogs.com/naturemickey]版权所有,未经许可请勿转载