人生苦短，我选Kotlin ——笔者

Kotlin相比Java很年轻，也更有潜力，其对函数式编程的支持也让其代码更加简洁，但在理解函数式编程的过程中，总会有些障碍，比如笔者在看到apply和with这两个方法的时候，就很奇怪，看了源码就更加糊涂了，本文以剖析apply和with这两个方法为线索，介绍下kotlin中函数式编程相关的几个概念。

函数类型（function type）

在函数式语言中，函数作为一种类型可以在函数间传递，那么如何区别不同的函数的类型呢？将函数的入参和返回值，作为一种函数类型，比如: (Int) -> Int 是一个函数类型，它的传入参数为Int，返回类型为Int，满足这个条件的函数为同一种类型的函数。

fun double(x: Int): Int {
    return 2 * x
}

比如double这个函数的类型为(Int) -> Int,它的入参是Int，返回值为Int.

由于函数为一种类型，我们可以像定义Int值一样定义一个函数类型的变量：

val double: (Int) -> Int = fun(value: Int): Int {
    return 2 * value
}

double的类型为函数，函数类型为(Int) -> Int 函数作为变量可以传递：

val doubleCopy = double
doubleCopy(1)

此时doubleCopy的类型和double的类型相同

高阶函数 (high order function)

如果一个函数将一个函数作为参数，或者返回一个函数，那么这种函数叫做high order function(高阶函数)

前面提到函数可以作为变量进行传递，将函数作为参数传递到另一个函数中，也是允许的，比如下面的例子：

// lock为高阶函数，接受2个参数，类型分别为：Lock，() -> T
// 前者为常见的Lock类型，后者为一个函数类型，这个类型的函数入参为空，返回值为T
fun <T> lock(lock: Lock, body: () -> T): T {
    lock.lock()
    try {
        return body()
    }
    finally {
        lock.unlock()
    }
}
// 调用方法
lock (lock,{sharedResource.operation()})
// 在kotlin中，如果一个函数的最后一个参数为函数，则可以将这个函数的函数体放到括号外面，就是常见的下面这种写法
lock (lock) {
    sharedResource.operation()
}

function-with-receiver type

kotlin中存在一个比较特殊的函数类型定义，它指定了函数的receiver（看起来和扩展方法比较像）

理解这个很关键，kotlin中很多基本的函数都是基于这种函数类型来实现的。

比如下面的代码段中，声明了intToLong这个函数的receiver类型为Int，只有Int类型的对象（A）可以调用intToLong这个方法，并且在intToLong函数体内，可以通过this来调用A中的函数

val intToLong: Int.() -> Long = { toLong() }

上面的代码段中，实际上调用的是Int类型本身定义的toLong方法：

//this可以省略掉
val intToLong: Int.() -> Long = { this.toLong() }
//可以编译通过，调用时，上面一句中的this即为3
val Long a = 3.intToLong()
//不可以编译通过，intToLong声明了receiver，只能被Int类型调用
val Long b = "3".intToLong()

分析下appy和with方法

这两个方法是kotlin中常用的方法，可以简化代码，让逻辑更加清晰整洁，但直接理解起来会有点绕，如果你看懂了前面讲到的几个概念之后，appy和with方法理解起来就相对容易很多

apply

apply是kotlin中常用的方法，它的官方文档中的定义是这样的：

apply:Calls the specified function block with this value as its receiver and returns this value.

我们来看下他的实现代码：

public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }

这里结合前面的函数相关概念，对这个方法进行分析：

apply为高阶函数，它接受一个参数block，类型为 T.() -> Unit,在apply的函数体内，调用了传入的block这个函数，然后返回调用apply函数的对象实例。

需要注意的是，block函数的类型为 function-with-receiver ，在block函数体内，可以通过this访问到T类型的实例。

//调用方法
fun getDeveloper(): Developer {
    return Developer().apply {
        developerName = "Amit Shekhar"
        developerAge = 22
    }
}
// 等同于下面这个方法
fun getDeveloper(): Developer {
    //apply 方法返回新创建的Developer()
    return Developer().apply {
        //this 为新创建的Developer()，可省略
        this.developerName = "Amit Shekhar"
        this.developerAge = 22
    }
}

with

with也是比较常用的方法，它的定义是这样的：

Calls the specified function block with the given receiver as its receiver and returns its result.

它的实现代码也只有一行

public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()

with为高阶函数，接收两个参数：receiver，类型为T，block 类型为 T.() -> R,为function-with-receiver type，只能被T类型的对象调用，同样，在block方法体内，可以通过this来调用到receiver。with返回的类型为R，和block的返回类型相同

fun getPersonFromDeveloper(developer: Developer): Person {
    return with(developer) {
        Person(developerName, developerAge)
    }
}

参考： learn kotlin apply vs with what is a receiver in kotlin What is a purpose of Lambda's with Receiver?

帮助理解Kotlin函数的3个概念