Kotlin学习之03

nonLocalReturn返回调用的方法，下面直接返回main方法

inline fun nonLocalReturn(block:() -> Unit) {

        block()

}

fun main() {

        nonLocalReturn {

                return

        }

}

禁止non-local-return，使用crossinline关键字

public inline fun IntArray.forEach(crossinline action: (Int) -> Unit): Unit {

        for(element in this) action(element)

}

使用该关键字后，将无法在该函数内使用return

内联属性

var pocket: Double = 0.0

var money: Double 

      inline get() = pocket

      inline set(value) {
         pocket = value

      }  

内联函数限制：

  内联函数只能访问对应类的public成员

  内联函数的参数不能被存储（赋值给变量）

  内联函数的参数只能传递给其他内联函数

标准库中常用的扩展函数：let、run、also、alppy、use

从各自的函数上看

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

repeat

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

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