Kotlin学习之03

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

let将T对象（即引用let的对象）作为函数的参数，那么在扩展函数内部，就可以用it替代T对象进行方法调用，而且let函数本身会对对象进行非空判断，返回值是函数返回值

@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
}

also将T对象（即引用also的对象）作为函数的参数，那么在扩展函数内部，就可以用it替代T对象进行方法调用，而且let函数本身会对对象进行非空判断，返回值是对象本身

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

将函数作为T对象（即引用run的对象）的扩展函数，则在函数内部可用this引用T对象，并使用T对象的方法，返回值是函数本身

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

将函数作为T对象（即引用apply的对象）的扩展函数，则在函数内部可用this引用T对象，并使用T对象的方法，返回值是对象本身

with

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

将函数作为对象的扩展函数，返回函数本身

takeIf

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

takeUnless

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

re peat

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

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