理解 Kotlin：一门现代工程语言是如何设计的

User user = findUser();

if (user != null) {
    System.out.println(user.getName());
}

val user = findUser()

user?.let {
    println(it.name)
}

“这个值可能为空”
        ↓
       T?

“这个函数不会正常返回”
        ↓
     Nothing

“这个属性第一次访问才初始化”
        ↓
     by lazy

“这段代码应该在某个对象的上下文中执行”
        ↓
  Lambda with Receiver

“暂停一段异步逻辑，之后再继续”
        ↓
     suspend

Constructor
Getter / Setter
equals
hashCode
toString

data class User(
    val name: String,
    val age: Int,
)

String

String?

var name: String = "Alice"

// name = null // 编译错误

var name: String? = null

name.length

name?.length

val length = name?.length ?: 0

fun printLength(value: Any) {
    if (value is String) {
        println(value.length)
    }
}

value 一定是 String

if (user != null) {
    println(user.name)
}

User?

User

fun fail(message: String): Nothing {
    error(message)
}

Unit
= 函数正常结束，只是没有有意义的数据返回

Nothing
= 函数根本不会正常结束

val user = findUser() ?: fail("User not found")

findUser()
    ↓
   User
    ↓
   user

null
 ↓
fail(...)
 ↓
后面的代码不会继续执行

User

sealed interface Result {
    data class Success(val value: String) : Result
    data class Error(val message: String) : Result
    data object Loading : Result
}

when (result) {
    is Result.Success -> show(result.value)
    is Result.Error -> showError(result.message)
    Result.Loading -> showLoading()
}

users.filter { it.age >= 18 }

remember {
    ...
}

launch {
    ...
}

button {
    ...
}

val square: (Int) -> Int = { x ->
    x * x
}

(Int) -> Int

{ x ->
    x * x
}

users.filter { user ->
    user.age >= 18
}

it

users.filter {
    it.age >= 18
}

users
    .filter { it.age >= 18 }
    .map { it.name }

对每一个 User
↓
留下 age >= 18 的

再对每一个剩下的 User
↓
取出 name

fun execute(block: () -> Unit)

execute({
    println("Hello")
})

execute {
    println("Hello")
}

foo {
    ...
}

foo({
    ...
})

fun String.isEmail(): Boolean {
    return '@' in this
}

"user@example.com".isEmail()

工具函数
↓
不再全部堆在 Utils 类里

对某个类型的操作
↓
可以自然地写在那个值后面

(Button) -> Unit

{ button ->
    button.text = "Play"
}

Button.() -> Unit

{
    text = "Play"
}

{
    this.text = "Play"
}

window {
    title = "My Game"

    button {
        text = "Play"
    }
}

class Button {
    var text = ""
}

class Window {
    var title = ""

    fun button(block: Button.() -> Unit) {
        val button = Button()
        button.block()
    }
}

fun window(block: Window.() -> Unit): Window {
    val window = Window()
    window.block()
    return window
}

window {
    title = "My Game"
}

window(...)
↓
普通函数

{ ... }
↓
Lambda

Window.() -> Unit
↓
Lambda 中 this = Window

button {
    text = "Play"
}

Button.() -> Unit
↓
Lambda 中 this = Button

var name: String = ""

var name: String = ""
    get() = field.uppercase()
    set(value) {
        field = value.trim()
    }

user.name

val name = delegate

val name by delegate

var

name
↓
delegate.getValue(...)

name = value
↓
delegate.setValue(...)

val config by lazy {
    loadConfig()
}

第一次读取 config
↓
执行 loadConfig()
↓
缓存结果
↓
之后重复使用

lazy { ... }
↓
提供“延迟计算一次”的对象

by
↓
把 Property 的访问委托给它

@Composable
fun Counter() {
    var count by remember {
        mutableStateOf(0)
    }

    Button(
        onClick = { count++ },
    ) {
        Text("Count: $count")
    }
}

remember { ... }
↓
普通函数 + Trailing Lambda

mutableStateOf(0)
↓
创建可观察状态

by
↓
把 State 暴露成普通 Property

Button { ... }
↓
函数 + Lambda

remember {
    mutableStateOf(0)
}

count++

suspend fun loadUser(): User

suspend

Thread
↓
实际执行代码的资源

Coroutine
↓
可以暂停和恢复的一段计算

执行
↓
遇到 Suspension Point
↓
暂停
↓
线程去做别的事情
↓
稍后恢复 Coroutine

delay(1000)

Thread.sleep(1000)

launch
async
withContext
Dispatchers.IO

kotlinx.coroutines

suspend
Continuation
Suspending Function

launch
async
withContext
Dispatchers
Flow
...

launch(Dispatchers.Main) {
    val data = withContext(Dispatchers.IO) {
        loadFile()
    }

    updateUI(data)
}

Token
↓
宏自己解析
↓
生成新的程序

正常 Kotlin Grammar
↓
函数 / Receiver / Convention
↓
构造 DSL

可能为空
→ T?

不会正常返回
→ Nothing

有限状态
→ sealed

Smart Cast
Data Class
类型推导

Lambda
Receiver
Extension
Property
Delegation
Operator Convention

DSL
Compose
Gradle Kotlin DSL
Ktor
...

Language
↓
suspend

Library
↓
launch / async / Dispatcher / Flow

foo {
    bar()
}

foo 是什么函数？

这个 Lambda 有没有 Receiver？

当前 this 是谁？

bar 是成员函数？
Extension？
还是来自外层 Receiver？

val x by something

getValue
setValue

Null Safety
Nothing
Smart Cast
Lambda
Receiver
Extension
Property
Delegation
Coroutine

某个关键字怎么写

users.filter { it.active }

val config by lazy { loadConfig() }

window {
    button {
        text = "Play"
    }
}

launch {
    ...
}