高阶函数

(Int, Int) -> Int
() -> Unit // 最简单的函数
// 一个函数对象也可以如下声明
val method: (Int) -> Int

((Int, Int) -> Unit)? // 可空类型
(Int) -> ((Int) -> Unit) // 嵌套表示
(Int) -> (Int) -> Unit // ->符号是右结合的
typealias Handler = () -> Unit // 类型别名

val f: (Int, Int) -> Int = fun (a: Int, b: Int): Int {
    return a + b
}
// 支持单表达式
val h: (Int, Int) -> Int = fun (a: Int, b: Int): Int = a + b
// 支持类型推断，类型声明和返回值类型不可省略
val m = fun (a: Int, b: Int): Int = a + b

val f: (Int, Int) -> Int = {
    // 参数写在括号内部，类型声明可以忽略
    a: Int, b: Int -> // 最后一个表达式作为返回值
    // statement
    // expression
}
// 支持类型推断，类型声明和返回值类型
val h = {
    a: Int, b: Int -> a + b
}

interface Handler {
    fun handle()
}
val handler: Handler = object : Handler {
    override fun handle() {
        // 匿名对象写法
    }
}
// 函数式接口可以添加fun关键字，开启lambda表达式支持
// 不是函数式接口添加fun关键字会编译错误
fun interface Comsumer {
    fun accept()
}
val consumer: Consumer = Consumer {
    // Lambda表达式
}

class Person {
    // 该函数的接收者函数类型为Person.() -> Unit
    fun say() {
    }
}

// 在字面量内部，隐式传入了接收者引用this
// 带有接收者时，lambda不支持类型推断，匿名函数支持类型推断，类型声明和返回值类型不可省略
val f: Person.() -> Unit = { say() }
val m: Person.() -> Unit = fun Person.(): Unit { say() }

class A {
    inner class B {
        // Int的扩展函数，接收者为Int
        fun Int.foo() { // 隐式标签@foo
            val a = this@A // A的this
            val b = this@B // B的this

            val c = this // foo()的接收者Int
            val c1 = this@foo // foo()的接收者Int

            // 带有String接收者的匿名函数字面量
            val funLit = fun String.() {
                val d = this // funLit的接收者String
            }
            
            // 带有String接收者的lambda函数字面量
            val funLit1: String.() -> Unit = {
                val d1 = this // funLit1的接收者String
            }

            val funLit2 = { s: String ->
                // foo()的接收者Int，因为它包含的lambda表达式没有任何接收者
                val d2 = this
            }
        }
    }
}

fun main() {
    f {
        println("lambda执行中")
        return
    }
}

inline fun f(h: () -> Unit) {
    println("lambda调用前")
    h()
    // lambda中的return被内联到调用处，直接return，该句不执行
    println("lambda调用后")
}

inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
    // notInlined不进行内联
}

class OrdersList: IndexedContainer {
    // 重载访问操作符
    operator fun get(index: Int) { 
        // statements
    }   
}