“完全”函数式编程

引子

有了面向对象编程,还需要函数式编程吗 ? 函数式编程,有什么妙处 ?

函数式的理念主要是:

  • 函数组合。函数式编程是将程序看成是一系列函数的组合。可以将函数作为变量进行赋值,作为函数参数传入,也可以作为返回值返回,函数无处不在。
  • 不可变。函数式编程不会改变传入的对象,返回的也是新创建的对象。
  • 确定性。相同的输入,经过函数式处理后,必然得到相同的输出。

这些理念导致的结果是:函数式编程,使得程序行为更容易预测和推断,尤其是在并发和并行的情形下。

本文将带着“函数式编程的有色眼镜”,重新审视日常的编程结构。重点是以函数视角来看待问题,暂不论及性能、软件工程等因素。

示例代码采用 Java 编写,其目的是贴近 Java 开发者的阅读习惯。同时,也应注意,由于函数式并不是 Java 的主要特性,因此在 Java 中是受限的能力。

基本结构

赋值

赋值是程序中最基础的行为。从函数视角来看,赋值实际上是一个常量函数。如下代码所示。 int i = 100 ,实际上可以用 Supplier<Integer> f = () -> 100 来替代。任何值出现的地方,都可以用值提供器来替代。这样做,可以增强函数的灵活性:因为值是固定的,但值源可以多种多样:变量、函数、文件、网络等。

public class Assignment {

  public static void main(String[]args) {
    int i = 100;
    System.out.println(i);

    Supplier<Integer> f = () -> 100;
    System.out.println(f.get());
  }
}

条件

来看条件怎么用函数式编程来实现。如下代码所示,是一个极为普通的函数,分别根据三种不同的条件返回不同的值。

public static Integer plainIfElse(int x) {
    if (x > 0) {
      return 1;
    }
    else if (x < 0) {
      return -1;
    }
    else {
      return 0;
    }
  }

怎么用函数式编程来改造呢 ? 前面说了,函数式编程是将程序看成是一系列函数的组合。首先从plainIfElse 提取出六个基本函数:

public static boolean ifPositive(int x) {
    return x > 0;
  }

  public static boolean ifNegative(int x) {
    return x < 0;
  }

  public static boolean ifZero(int x) {
    return x == 0;
  }

  public static Integer positiveUnit() {
    return 1;
  }

  public static Integer negativeUnit() {
    return -1;
  }

  public static Integer zero() {
    return 0;
  }

现在的问题是:怎么组合这些基本函数得到与 plainIfElse 一样的效果呢?很容易,将 if-elseif-else 解析为:

if (A) { actA }
if (B) { actB }
if (C) { actC }

这是一个 Map 结构。key 是条件函数,value 是行为函数。因此可以考虑用 Map[Predicate,Supplier] 来模拟,如下代码所示:

public static Supplier<Integer> mapFunc(int x) {
    Map<Predicate<Integer>, Supplier<Integer>> condMap = new HashMap<>();
    condMap.put(Condition::ifPositive, Condition::positiveUnit);
    condMap.put(Condition::ifNegative, Condition::negativeUnit);
    condMap.put(Condition::ifZero, Condition::zero);
    return travelWithGeneric(condMap, x);
  }

接下来,只要遍历所有的 key ,找到满足条件函数的第一个 key ,然后调用 value 即可:

public static <T,R> Supplier<R> travelWithGeneric(Map<Predicate<T>, Supplier<R>> map, T x) {
    return map.entrySet().stream().filter((k) -> k.getKey().test(x)).findFirst().map((k) -> k.getValue()).get();
  }

Emmm ... Seems Perfect .


不过,完全消除了 if-else 了吗?并没有。 事实上 filter + findFirst 隐式地含有了 if-else 的味道。这说明:无法彻底地消除条件,只是在适当的抽象层次上隐藏了。

进一步思考,if-else 可以拆成两个 if-then 语句。 if-then 可以说是最原子的操作了。顺序语句,本质上也是 if-then : if exec current ok , then next ; if exec not ok, exit .

通用IF

既然 if-then 是原子操作,可以提供几个方便的函数:

public class CommonIF {

  public static <T, R> R ifElse(Predicate<T> cond, T t, Function<T, R> ifFunc, Supplier<R> defaultFunc ) {
    return cond.test(t) ? ifFunc.apply(t) : defaultFunc.get();
  }

  public static <T, R> R ifElse(Predicate<T> cond, T t, Supplier<R> ifSupplier, Supplier<R> defaultSupplier ) {
    return cond.test(t) ? ifSupplier.get() : defaultSupplier.get();
  }

  public static <T, R> Supplier<R> ifElseReturnSupplier(Predicate<T> cond, T t, Supplier<R> ifSupplier, Supplier<R> defaultSupplier ) {
    return cond.test(t) ? ifSupplier : defaultSupplier;
  }

  public static <T> void ifThen(Predicate<T> cond, T t, Consumer<T> action) {
    if (cond.test(t)) {
      action.accept(t);
    }
  }

  public static <T> boolean alwaysTrue(T t) {
    return true;
  }
}

应用 CommonIF 的函数,可以改写 if-elseif-else 为嵌套的 if-else :

public static Supplier<Integer> ifElseWithFunctional(int x) {
    return CommonIF.ifElseReturnSupplier(Condition::ifPositive, x,
                                         Condition::positiveUnit,
                                         CommonIF.ifElseReturnSupplier(Condition::ifNegative, x, Condition::negativeUnit, Condition::zero ) );
  }

循环

现在,来看下循环。下面是一段很普通的循环代码:

    Integer sum = 0;
    List<Integer> list = Arrays.asList(1,2,3,4,5);
    for (int i=0; i < list.size(); i++) {
      sum += list.get(i);
    }
    System.out.println(sum);

    Integer multiply = 1;
    for (int i=0; i < list.size(); i++) {
      multiply *= list.get(i);
    }
    System.out.println(multiply);

聪明的读者很快就看出了:上述两段代码的结构都是对容器的元素进行 reduce ,差异只在于:一个初始值和 reduce 操作符。怎么将 reduce 这种相似性抽离出来呢 ? 如下代码所示。 reduct 的操作是:1. 将结果 result 赋值为初始值 init ; 2. 每次从 list 取出一个元素 e , 与 result 进行指定运算,然后存入 result; 3. 列表遍历结束后,返回 result .

NOTE:list 中的元素,既可以是数据,也可以是函数。 是函数的情况,将在“循环”这一节的函数 pipe 展示出来。泛型结合函数式,可以使得一个简单函数的能力变得非常强大。

public static <E,T> T reduce(List<E> list, BiFunction<E,T,T> biFunc, Supplier<T> init) {
    T result = init.get();
    for (E e: list) {
      result = biFunc.apply(e, result);
    }
    return result;
  }

现在可以写作:

System.out.println("func sum:" + reduce(list, (x,y) -> x+y, () -> 0));
System.out.println("func multiply: " + reduce(list, (x,y) -> x*y, () -> 1));

是不是足够简洁 ?我们发现了函数式编程的一大妙处。

实际应用

在运用函数视角解析基本编程结构之后,来看一点实际应用。

PipeLine

PipeLine 是函数式编程的典型应用。PipeLine 通俗地说,就是一个流水线,通过一系列工序共同协作完成一个确定目标。比如说,导出功能,就是“查询-详情-过滤-排序-格式化-生成文件-上传文件”的流水线。如下代码,展示了如何用函数式实现一个 PipeLine : supplier 提供的数据集,经过一系列的 filters 加工,最后经过 format 格式化输出。

public class PipeLine {

  public static void main(String[] args) {
    List<String> result = pipe(PipeLine::supplier, Arrays.asList(PipeLine::sorter, PipeLine::uniq), PipeLine::format);
    System.out.println(result);
  }

  public static <T,R> R pipe(Supplier<List<T>> supplier, List<Function<List<T>, List<T>>> filters,
                                   Function<List<T>,R> format) {
    return format.apply(Loop.reduce(filters, (f, mid) -> f.apply(mid), supplier));
  }


  public static List<String> supplier() {
    return Arrays.asList("E20191219221321025200001", "E20181219165942035900001", "E20181219165942035900001", "E20191119165942035900001");
  }

  public static List<String> sorter(List<String> list) {
    Collections.sort(list);
    return list;
  }

  public static List<String> uniq(List<String> list) {
    return list.stream().distinct().collect(Collectors.toList());
  }

  public static List<String> format(List<String> list) {
    return list.stream().map(
        (s) -> s + " " + s.substring(1,5) + " " + s.substring(5,7) + ":" + s.substring(7,9) + ":" + s.substring(9,11)
    ).collect(Collectors.toList());
  }
}

装饰器

最后,来看一个装饰器栗子,展示函数组合的强大威力。

大家还隐约记得一个公式: (sinx)^2 + (cosx)^2 = 1。如果要写成程序,也是很容易的:

double x = Math.pow(sin(x),2) + Math.pow(cos(x), 2); 

如果我需要的是 f(x)^2 + g(x)^2 呢?细心的读者发现了,这里的结构都是 f(x)^n ,因此将这个结构抽离出来。 pow 对 f 做了个幂次封装,现在我们得到了 F(x) = f(x)^n + g(x)^n 的能力。

  /** 将指定函数的值封装幂次函数 pow(f, n) = (f(x))^n */
  public static <T> Function<T, Double> pow(final Function<T,Double> func, final int n) {
    return x -> Math.pow(func.apply(x), (double)n);
  }

现在可以写作:double x = pow(Math::sin, 2).apply(x) + pow(Math::cos, 2).apply(x);

请注意,这里 + 仍然是固定的,我希望也不局限于加号,而是任意可能的操作符,也就是想构造: H(x) = Hop(f(x), g(x))。这样,就需要支持将 + 这个操作符,以函数参数的形式传入:

public static <T> Function<BiFunction<T,T,T>, Function<T,T>> op(Function<T,T> funcx, Function<T,T> funcy) {
    return opFunc -> aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT));
}

现在可以写作:

 Function<Double,Double> sumSquare = op(pow(Math::sin, 2), pow(Math::cos, 2)).apply((a,b)->a+b);
System.out.println(sumSquare.apply(x));

对于 f(x)^n ,事实上,可以写成更抽象的形式: f(g(x)) = y -> f(y), y = x -> g(x) :

/** 将两个函数组合成一个叠加函数, compose(f,g) = f(g) */
  public static <T> Function<T, T> compose(Function<T,T> funcx, Function<T,T> funcy) {
    return x -> funcx.apply(funcy.apply(x));
  }

  /** 将若干个函数组合成一个叠加函数, compose(f1,f2,...fn) = f1(f2(...(fn))) */
  public static <T> Function<T, T> compose(Function<T,T>... extraFuncs) {
    if (extraFuncs == null || extraFuncs.length == 0) {
      return x->x;
    }
    return x -> Arrays.stream(extraFuncs).reduce(y->y,  FunctionImplementingDecrator::compose).apply(x);
  }

现在,我们获得了更强的灵活性,可以任意构造想要的函数:

Function<Double,Double> another = op(compose((d)->d*d, Math::sin), compose((d)->d*d, Math::cos)).apply((a,b)->a+b);
System.out.println(another.apply(x));

Function<Double,Double> third = compose(d->d*d, d->d+1, d->d*2, d->d*d*d); // (2x^3+1)^2
System.out.println(third.apply(3d));

这里展示了函数式编程的强大之处:通过短小的简单函数,很容易组合出具有强大功能的复合函数。

小结

函数式编程通过任意组合短小简单的函数,构造具有强大能力的复合函数,同时可以保持代码非常简洁。

通过函数式编程训练,将会习惯于识别出程序中的基本结构,善于提炼、抽象和组合基本结构来构造更复杂的结构,逐步收获强大的结构提炼和抽象能力。而结构化抽象,正是软件开发与设计的第一性原理,也是最基本最强大的内功。

读完本文,你是否从中受到了启发呢 ?

posted @ 2019-12-20 21:30  琴水玉  阅读(591)  评论(0编辑  收藏  举报