1
// apply
2
public inline fun <T> T.apply(block: T.() -> Unit): T { block() return this }
3
// run
4
public inline fun <T, R> T.run(block: T.() -> R): R { return block() }
5
// let
6
public inline fun <T, R> T.let(block: (T) -> R): R { return block(this) }

1
// 使用高阶函数简化网络请求处理
2
fun <T> Call<T>.enqueue(
3
    onSuccess: (response: Response<T>) -> Unit,
4
    onError: (error: Throwable) -> Unit,
5
    onCancel: () -> Unit
6
) {
7
    enqueue(object : Callback<T> {
8
        override fun onResponse(call: Call<T>, response: Response<T>) {
9
            if (response.isSuccessful) {
10
                onSuccess(response)
11
            } else {
12
                onError(Exception("Request failed with code ${response.code()}"))
13
            }
14
        }
15

16
        override fun onFailure(call: Call<T>, t: Throwable) {
17
            if (!call.isCanceled) {
18
                onError(t)
19
            } else {
20
                onCancel()
21
            }
22
        }
23
    })
24
}
25

26
// 使用的时候
27
 call.enqueue(
28
            onSuccess = { response ->
29
                // 在这里处理网络请求成功的逻辑
30

31
            },
32
            onError = { error ->
33
                // 在这里处理网络请求失败的逻辑
34
            },
35
            onCancel = {
36
                // 在这里处理网络请求取消的逻辑
37
            }
38
        )

1
// 使用高阶函数简化回调函数
2
fun EditText.doOnTextChanged(action: (text: CharSequence?, start: Int, before: Int, count: Int) -> Unit) {
3
    addTextChangedListener(object : TextWatcher {
4
        override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
5
        }
6

7
        override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
8
            action(s, start, before, count)
9
        }
10

11
        override fun afterTextChanged(s: Editable?) {
12
        }
13
    })
14
}
15

16
// 使用的时候只需要关系一个回调就可以
17
  editText.doOnTextChanged { text, _, _, _ ->
18
            // 在这里处理输入框文本变化的逻辑
19
  }