第六章 Kotlin 函数式编程（FP）

正式上架：《Kotlin极简教程》Official on shelves: Kotlin Programming minimalist tutorial
京东JD：https://item.jd.com/12181725.html
天猫Tmall：https://detail.tmall.com/item.htm?id=558540170670

1. 函数式编程概述

从本质上来说， 程序就是一系列有序执行的指令集合。 如何将指令集合组织成可靠可用可信赖的软件（美妙的逻辑之塔）， 这是个问题。

首先，什么是函数式编程，这并没有唯一定义，它只是广泛聚合了一些编程风格的特性，我们可以将它与面向对象编程OOP进行对比， 两者区别是，OOP主要聚焦于数据的区别，而FP则注重数据结构的一致性。

函数编程(简称FP)不只代指Haskell Scala等之类的语言，还表示一种编程思维，软件思考方式，也称面向函数编程。

编程的本质是组合，组合的本质是范畴Category，而范畴是函数的组合。

面向对象编程OOP特征：

• 数据和对数据的操作紧紧耦合
• 对象隐藏它们操作的实现细节，其他对象调用这些操作只需要通过接口。
• 核心抽象模型是数据自己
• 核心活动是组合新对象和拓展已经存在的对象，通过加入新的方法实现。

函数式编程FP特征：

• 数据与函数是松耦合的
• 函数隐藏了它们的实现，语言的抽象是函数，以及将函数组合起来表达。
• 核心抽象模型是函数，不是数据结构
• 核心活动是编写新的函数。
• 变量缺省是不变的，减少可变性变量的使用，并发性好[1]

如果说OOP还有很多人可能受静态数据思路影响，那么FP 带来完全是动态事件，FP让我们直接用动词思考，用函数解决问题。

面向对象和面向函数一直在争论，实际上纯粹的OOP和纯粹的FP都是极端的，对于OOP来讲：存在的并一定都是对象，函数就不是对象；对于FP来说：存在的并不总是纯粹的，副作用总是真实存在。

总之，面向对象侧重于自顶向下架构层层分解，函数编程侧重于自底向上层层组合。

2. Kotlin函数式编程

Kotlin对函数式编程的实现恰到好处。

2.1 函数是什么？

在数学中，我们这样定义一个函数：

给定一个集合A,对A施加对应法则f, 记作f（A）, 得到另一集合B, 也就是B=f(A). 我们记作：
** f: A -> B **
这个关系式就叫函数关系式, 简称函数.

函数的类型是: A->B。 意思是，if A then , we have B = f(A) . 函数代表一种关系 f 的蕴涵逻辑流。这种蕴涵逻辑流，其实就是映射（Mapping）。

一切皆是映射。

我们说组合是编程的本质，其实，组合就是建立映射关系。

我们说，

程序 = 算法+数据结构

我们把程序看做图论里面的一张图G，这里的数据结构就是图G的节点Node， 而算法逻辑就是这些节点Node之间的Edge。整个的图G就是一幅美妙的抽象逻辑之塔的** 映射图 **。

2.2 函数指针

我们使用::引用一个函数。

/**
 * "Callable References" or "Feature Literals", i.e. an ability to pass
 * named functions or properties as values. Users often ask
 * "I have a foo() function, how do I pass it as an argument?".
 * The answer is: "you prefix it with a `::`".
 */

fun main(args: Array<String>) {
    val numbers = listOf(1, 2, 3)
    println(numbers.filter(::isOdd))
}

fun isOdd(x: Int) = x % 2 != 0

运行结果： [1, 3]

2.3 复合函数(高阶函数(Higher-order function))

函数式编程风格让我们复合函数的写法跟数学表达式一样简洁。看了下面的复合函数的例子，你会发现Kotlin的FP的实现相当简洁，跟纯数学的表达式，相当接近了：

/**
 * The composition function return a composition of two functions passed to it:
 * compose(f, g) = f(g(*)).
 * Now, you can apply it to callable references.
 */

fun main(args: Array<String>) {
    val oddLength = compose(::isOdd, ::length)
    val strings = listOf("a", "ab", "abc")
    println(strings.filter(oddLength))
}

fun isOdd(x: Int) = x % 2 != 0
fun length(s: String) = s.length

fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}

运行结果： [a,abc]

简单说明下

val oddLength = compose(::isOdd, ::length)
    val strings = listOf("a", "ab", "abc")
    println(strings.filter(oddLength))

这就是数学中，复合函数的定义：

h = h(f(g))

g: A->B
f: B->C
h: A->C

g(A)=B
h(A) = f(B) = f(g(A)) = C

只是代码中的写法是：

h=compose( f, g )
h=compose( f(g(A)), g(A) )

/**
 * The composition function return a composition of two functions passed to it:
 * compose(f, g) = f(g(*)).
 * Now, you can apply it to callable references.
 */

fun main(args: Array<String>) {
    val oddLength = compose(::isOdd, ::length)
    val strings = listOf("a", "ab", "abc")
    println(strings.filter(oddLength))
    
    println(strings.filter(::hasA))
    println(strings.filter(::hasB))
    
    val hasBStrings = strings.filter(::hasB)
    println(hasBStrings)
    
    val evenLength = compose(::isEven,::length)
    println(hasBStrings.filter(evenLength))
    
    
}

fun isOdd(x: Int) = x % 2 != 0
fun isEven(x:Int) = x % 2 == 0
fun length(s: String) = s.length
fun hasA(x: String) = x.contains("a")
fun hasB(x: String) = x.contains("b")



fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}

fun <W,X,Y,Z> compose2( h: (Y) -> Z, f:(X) -> Y,g:(W) -> X): (W) -> Z {
    return  {x -> h(f(g(x)))} 
}

你看这个复合函数

fun <W,X,Y,Z> compose2( h: (Y) -> Z, f:(X) -> Y,g:(W) -> X): (W) -> Z {
    return  {x -> h(f(g(x)))} 
}

看起来很像数学定义，语言可谓优雅漂亮，看着很舒服。

运行结果：

[a, abc]
[a, ab, abc]
[ab, abc]
[ab, abc]
[ab]

2.4 闭包（Lambda表达式，匿名函数）

我们知道，函数名其实就是一个指向函数的引用变量。如果没有这样一个显式的变量名，编译器当然也会给这段代码按照一个默认规则，创造一个默认的引用。本质其实就是指令中断现场的地址的存储，执行完一段代码（函数逻辑）之后再返回执行之前的地址，继续执行下面的代码。

函数与闭包（匿名函数、无名函数）是 Kotlin 语言提供的重要特性之一。Kotlin的闭包跟Groovy的闭包使用起来类似，直截了当。

在 Kotlin 中与其说一等公民是函数，不如说一等公民是闭包。

例如在 Kotlin 中，你可以写出这种怪异的代码

fun main(args: Array<String>) {
    test
}
val test = if (5 > 3) {
    print("yes")
} else {
    print("no")
}

这段代码会输出yes。

这里的if 语句，就是一个闭包。

我们说的Lambda 表达式，就是匿名函数，就是闭包。而匿名函数（闭包），就是匿名的功能代码块了。

Lambda表达式基于数学中的λ演算得名，Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。

Lambda表达式基本语法如下：

• Lambda表达一般使用{ }包围。
• 参数（如果有的话）在->前定义，参数类型可能是省略的。
• 函数体跟在->后面。

我们先来看一个 Lambda 表达式的例子：

// LambdaExpression.kt
package com.easy.kotlin

/**
 * Created by jack on 2017/5/30.
 */

//    Lambda 表达式
val fsum0 = { x: Int, y: Int ->  x + y  }
val fsum1 = { x: Int, y: Int -> { x + y } }
val fsum2 = fun(x: Int, y: Int): Int = x + y
val fsum3 = fun Int.(other: Int): Int = this + other


fun main(args: Array<String>) {
    println(fsum0(1, 1))
    println(fsum0.invoke(1,1))

    println(fsum1(1, 1).invoke())
    println(fsum2(1, 1))
    println(1.fsum3(1))

}

可以看到我们定义了一个变量 fsum0，赋值为一个 Lambda 表达式:

{ x: Int, y: Int -> x + y }

Lambda 表达式用一对大括号括起来，后面先依次写下参数及其类型，如果没有就不写，接着写下-> ，这表明后面的是函数体了，函数体的最后一句的表达式结果就是 Lambda 表达式的返回值，比如这里的返回值就是参数求和的结果。

后面我们用 () 的形式: fsum0(1, 1) 调用这个 Lambda 表达式，其实这个 () 对应的是 invoke 方法，换句话说，我们在这里也可以这么写：

fsum0.invoke(1,1)

这两种调用的写法是完全等价的。

我们看到 val fsum1 = { x: Int, y: Int -> { x + y } } 这一句， 跟fsum0相比，函数体多了个{}。 意思就大不同了。这表明fsum1本身就是一个函数。其调用方式为：

fsum1(1, 1).invoke()

再看 val fsum3 = fun Int.(other: Int): Int = this + other , 匿名函数语法允许我们直接指定函数字面值的接收者类型（这里是Int）。然后，我们直接这样调用函数：1.fsum3(1)。

我们用kotlinc编译LambdaExpression.kt之后，发现目录下生成了这么多的类

./LambdaExpression.kt
./LambdaExpressionKt$fsum0$1.class
./LambdaExpressionKt$fsum1$1$1.class
./LambdaExpressionKt$fsum1$1.class
./LambdaExpressionKt$fsum2$1.class
./LambdaExpressionKt$fsum3$1.class
./LambdaExpressionKt.class

这个我们很熟悉，就是Java中我们看到的内部类。默认命名规则依然是熟悉的配方：$1, $2 ...

我们看这一行

val fsum1 = { x: Int, y: Int -> { x + y } }

对应编译成了两个类文件：

./LambdaExpressionKt$fsum1$1$1.class 
./LambdaExpressionKt$fsum1$1.class

其中，./LambdaExpressionKt$fsum1$1$1.class 对应 val fsum1 = { x: Int, y: Int -> { x + y } } 中的{ x + y } 。

而./LambdaExpressionKt$fsum1$1.class 对应的是 val fsum1 = { ... } 外面的 { }。

自执行闭包就是在定义闭包的同时直接执行闭包，一般用于初始化上下文环境。 例如：

{ x: Int, y: Int ->
    println("${x + y}")
}(1, 3)

闭包（Lambda表达式，匿名函数），在Thread线程执行逻辑里面就显得非常简洁了：

    fun testThread() {
        val startHookThread = Thread({
            println("Hello, I am startHookThread")
        })
        startHookThread.start()
    }

我们会觉得，代码就应该这么写。而不像之前在Java中，要写上一堆样板代码。在Java 8中，也支持了Lambda表达式，写法简洁了许多了。

不过，虽然我们写代码的时候，没有给这段代码块名字， 但是真正到了指令级代码的时候， 还是需要名字的。所以，编译器在处理的时候，会自动给这段匿名函数生成一个名字的

这段代码，kotlinc编译成了：

// access flags 0x1A
  // signature (Lkotlin/jvm/internal/Ref$ObjectRef<Ljava/lang/String;>;Ljava/lang/String;)V
  // declaration: void kotlin$lambda-0(kotlin.jvm.internal.Ref$ObjectRef<java.lang.String>, java.lang.String)
  private final static kotlin$lambda-0(Lkotlin/jvm/internal/Ref$ObjectRef;Ljava/lang/String;)V
    ALOAD 1
    INVOKESTATIC kotlin/io/ConsoleKt.println (Ljava/lang/Object;)V
    ALOAD 0
    NEW java/lang/StringBuilder
    DUP
    ALOAD 0
    GETFIELD kotlin/jvm/internal/Ref$ObjectRef.element : Ljava/lang/Object;
    CHECKCAST java/lang/String
    INVOKESPECIAL java/lang/StringBuilder.<init> (Ljava/lang/String;)V
    ALOAD 1
    INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;)Ljava/lang/StringBuilder;
    INVOKEVIRTUAL java/lang/StringBuilder.toString ()Ljava/lang/String;
    PUTFIELD kotlin/jvm/internal/Ref$ObjectRef.element : Ljava/lang/Object;
    RETURN
   L0
   L1
    MAXSTACK = 4
    MAXLOCALS = 2

  // access flags 0x11
  public final testThread()V
    NEW java/lang/Thread
    DUP
    INVOKESTATIC jason/chen/mini_springboot/restful/service/KotlincService.testThread$lambda-0 ()V
    ACONST_NULL
   L0
    INVOKESPECIAL java/lang/Thread.<init> (Lkotlin/jvm/functions/Function0;)V
    ASTORE 1
   L1
    ALOAD 1
    INVOKEVIRTUAL java/lang/Thread.start ()V
    RETURN
   L2
    LOCALVARIABLE startHookThread Ljava/lang/Thread; L1 L2 1
    MAXSTACK = 3
    MAXLOCALS = 2

  // access flags 0x1A
  private final static testThread$lambda-0()V
    LDC "Hello, I am startHookThread"
    INVOKESTATIC kotlin/io/ConsoleKt.println (Ljava/lang/Object;)V
    RETURN
   L0
   L1
    MAXSTACK = 1
    MAXLOCALS = 0

我们可以看出，在testThread()函数里面，有这么一段代码：

NEW java/lang/Thread
    DUP
    INVOKESTATIC jason/chen/mini_springboot/restful/service/KotlincService.testThread$lambda-0 ()V
    ACONST_NULL
   L0
    INVOKESPECIAL java/lang/Thread.<init> (Lkotlin/jvm/functions/Function0;)V

其中，$lambda-0() 函数签名如下：

private final static kotlin$lambda-0(Lkotlin/jvm/internal/Ref$ObjectRef;Ljava/lang/String;)

这就是闭包（匿名函数，Lambda表达式）背后真正的执行过程。更多的事情，由编译器去完成了。

Kotlin编译器在编译前端（即词法分析、语法分析、语义分析、中间代码生成）和Java是基本一致的。与Java不同的地方在编译后面的目标代码生成环节。Kotlin编译器在目标代码生成环节做了很多类似于Java封装的事情，比如自动生成Getter/Setter代码、Companion Object转变成静态类、修改类属性为final不可继承等等工作。大部分Kotlin的特性都在这个环节处理产生。可以这么说，Kotlin将我们本来在代码层做的一些封装工作转移到了编译后端阶段，以使得我们可以更加简洁的使用Kotlin语言。

感谢Kotlin编译器，让我们能够很享受地用kotlin写代码。

2.5 filter函数

    val ints = intArrayOf(-1, -2, 3, 4, 5, 6)
    var sum = 0
    ints.filter { it > 0 }.forEach {
        sum = it.fsum3(sum)
        //sum += it;
    }
    println(sum)//18

这里的forEach函数

/**
 * Performs the given [action] on each element.
 */
@kotlin.internal.HidesMembers
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

是kotlin.collections._Collections.kt里面的一个扩展方法。

2.6 map函数

    val doubled = ints.map { value -> value * 2 }
    println(doubled)

参考资料

1.http://www.jdon.com/functional.html