Kotlin学习之03_代码007(未授权)

本文介绍: a ls o将T对象（即引用 a ls o的对象）作为函数的参数，那么在扩展函数内部，就可以用i t替代T对象进行方法调用，而且let 函数本身会对对象进行非空判断，返回值是对象本身。let将T对象（即引用 let的对象）作为函数的参数，那么在扩展函数内部，就可以用i t替代T对象进行方法调用，而且let 函数本身会对对象进行非空判断，返回值是函数返回值。将函数作为T对象（即引用 run的对象）的扩展函数，则在函数内部可用th i s 引用T对象，并使用T对象的方法，返回值是函数本身。将函数作为对象的扩展函数，返回函数本身。

nonLoc alRe turn返回调用的方法，下面直接返回 main方法

inline fun nonLo calRe turn(block:() -&g t; Uni t) {

block()

}

fun main() {

nonLo calReturn {

@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}

@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {`
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return receiver.block()
}

public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (predicate(this)) this else null
}

public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (!predicate(this)) this else null
}

public inline fun repeat(times: Int, action: (Int) -> Unit) {
    contract { callsInPlace(action) }

    for (index in 0 until times) {
        action(index)
    }
}