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

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

Kotlin开发者社区

专注分享 Java、 Kotlin、Spring/Spring Boot、MySQL、redis、neo4j、NoSQL、Android、JavaScript、React、Node、函数式编程、编程思想、"高可用，高性能，高实时"大型分布式系统架构设计主题。

High availability, high performance, high real-time large-scale distributed system architecture design。

分布式框架：Zookeeper、分布式中间件框架等
分布式存储：GridFS、FastDFS、TFS、MemCache、redis等
分布式数据库：Cobar、tddl、Amoeba、Mycat
云计算、大数据、AI算法
虚拟化、云原生技术
分布式计算框架：MapReduce、Hadoop、Storm、Flink等
分布式通信机制：Dubbo、RPC调用、共享远程数据、消息队列等
消息队列MQ：Kafka、MetaQ，RocketMQ
怎样打造高可用系统：基于硬件、软件中间件、系统架构等一些典型方案的实现：HAProxy、基于Corosync+Pacemaker的高可用集群套件中间件系统
Mycat架构分布式演进
大数据Join背后的难题：数据、网络、内存和计算能力的矛盾和调和
Java分布式系统中的高性能难题：AIO，NIO，Netty还是自己开发框架？
高性能事件派发机制：线程池模型、Disruptor模型等等。。。

合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。不积跬步，无以至千里；不积小流，无以成江河。

Kotlin 简介

Kotlin是一门非研究性的语言，它是一门非常务实的工业级编程语言，它的使命就是帮助程序员们解决实际工程实践中的问题。使用Kotlin 让 Java程序员们的生活变得更好，Java中的那些空指针错误，浪费时间的冗长的样板代码，啰嗦的语法限制等等，在Kotlin中统统消失。Kotlin 简单务实，语法简洁而强大，安全且表达力强，极富生产力。

Java诞生于1995年，至今已有23年历史。当前最新版本是 Java 9。在 JVM 生态不断发展繁荣的过程中，也诞生了Scala、Groovy、Clojure 等兄弟语言。

Kotlin 也正是 JVM 家族中的优秀一员。Kotlin是一种现代语言（版本1.0于2016年2月发布）。它最初的目的是像Scala那样，优化Java语言的缺陷，提供更加简单实用的编程语言特性，并且解决了性能上的问题，比如编译时间。 JetBrains在这些方面做得非常出色。

Kotlin语言的特性

用 Java 开发多年以后，能够尝试一些新的东西真是太棒了。如果您是 Java 开发人员，使用 Kotlin 将会非常自然流畅。如果你是一个Swift开发者，你将会感到似曾相识，比如可空性（Nullability）。 Kotlin语言的特性有：

1.简洁

大幅减少样板代码量。

2.与Java的100%互操作性

Kotlin可以直接与Java类交互，反之亦然。这个特性使得我们可以直接重用我们的代码库，并将其迁移到 Kotlin中。由于Java的互操作性几乎无处不在。我们可以直接访问平台API以及现有的代码库，同时仍然享受和使用 Kotlin 的所有强大的现代语言功能。

3.扩展函数

Kotlin 类似于 C# 和 Gosu, 它提供了为现有类提供新功能扩展的能力，而不必从该类继承或使用任何类型的设计模式 (如装饰器模式)。

4.函数式编程

Kotlin 语言一等支持函数式编程，就像Scala一样。具备高阶函数、Lambda 表达式等函数式基本特性。

5.默认和命名参数

在Kotlin中，您可以为函数中的参数设置一个默认值，并给每个参数一个名称。这有助于编写易读的代码。

6.强大的开发工具支持

而由于是JetBrains出品，我们拥有很棒的IDE支持。虽然Java到Kotlin的自动转换并不是100% OK 的，但它确实是一个非常好的工具。使用 IDEA 的工具转换Java代码为 Kotlin 代码时，可以轻松地重用60％-70％的结果代码，而且修改成本很小。

Kotlin 除了简洁强大的语法特性外，还有实用性非常强的API以及围绕它构建的生态系统。例如：集合类 API、IO 扩展类、反射API 等。同时 Kotlin 社区也提供了丰富的文档和大量的学习资料，还有在线REPL。

A modern programming language that makes developers happier. Open source forever

图来自《Kotlin从入门到进阶实战》 (陈光剑，清华大学出版社)

图来自《Kotlin从入门到进阶实战》 (陈光剑，清华大学出版社)

https://kotlinlang.org/