In the first peace of code, it said that the `thro...

# getting-started

[Jason5lee]

In the first peace of code, it said that the throw is unreachable. But after I removed it there is an compile error. Is it a known issue?

[Kirill Grouchnikov]

The first piece marks throw as unreachable because you have an infinite loop. The second piece says that since you never return and never throw, this function can not return the promised Int

[Jason5lee]

Then why the first piece has no compile error? It can not return the promised Int either.

[Kirill Grouchnikov]

It's because of the throw that is considered to be a "valid" escape from such a function. Except that the throw can't be reached either.

[Jason5lee]

btw the code compiles once run is removed.

[ephemient]

throw expression has type Nothing, loop has Unit type. although arguably an infinite loop should also have type Nothing, Kotlin compiler can't infer that now. https://youtrack.jetbrains.com/issue/KT-25023

[Jason5lee]

Fair. Just not using run solves it, not a big deal.

[Youssef Shoaib [MOD]]

Yeah run makes the compiler consider the type of the lambda to be returning Unit

[ephemient]

IMO Rust gets this right by having a separate control structure for infinite loops, which you can sort of emulate with

inline fun loop(block: () -> Unit): Nothing {
    while (true) block()
}

but the Rust version also allows for break value, which I don't see an elegant way to implement in Kotlin

[ephemient]

you could get the interface with

interface LoopScope<in T> {
    fun emit(value: T): Nothing
}

class Return(val value: Any?) : Throwable("", null, false, false)

inline fun <T> loop(@BuilderInference block: LoopScope<T>.() -> Unit): T {
    val loopScope = object : LoopScope<T> {
        override fun emit(value: T): Nothing {
            throw Return(value)
        }
    }
    try {
        while (true) loopScope.block()
    } catch (e: Return) {
        @Suppress("UNCHECKED_CAST")
        return e.value as T
    }
}

or

suspend fun <T> loop(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): T = flow {
    while (true) block()
}.first()

which can both be used like

assert(loop { if (Random.nextInt(10) == 0) emit(true) })

but both implementations have pretty annoying downsides

[Youssef Shoaib [MOD]]

You could do:

inline fun loop(block: () -> Unit): Nothing {
    while (true) block()
}
fun main() {
    val isZero = run {
        loop {
            if (Random.nextInt(10) == 0) return@run true
        }
    }
}

In Kotlin, whenever you find the notion of "breaking out" of some scope, one of the first things you can try is just to nest that scope inside a run.
Alternatively, similar to your previous example but simplified:

typealias Emit<T> = (T) -> Unit
private object UNINITIALIZED
inline fun <T> loop(block: (Emit) -> Unit): T {
    val returnValue: Any? = UNINITIALIZED
    while (returnValue == UNINITIALIZED) block { returnValue = it }
    return returnValue as T
}

Note however that the returnValue setter won't be inlined because the compiler can't inline higher-higher-order functions, if you will.

[ephemient]

the second isn't right:

loop { ret ->
    ret(1)
    throw
}

throws instead of returning