A modern programming language that makes developers happier.

kotlinlang

It seems a bit odd that I'm required to explicitly state the return type of `Nothing` in this case...
```
fun justThrowIt(): Nothing = throw IOException()
```
...while here, I'm not:
```
fun justLoop() { while (true) {} }
```

I can explicitly state the return type as `Nothing` and it does still compile.

`fun justThrowIt() { throw IOException() }` works too

`"'Nothing' return type needs to be specified explicitly."`

If you omit the return type, you've explicitly made it Unit.

my version is different from your version

If the method is an expression, then the return type is inferred.

<@U0D06TWMA> Oh gosh, you're right, it is different.

Yeah:
```
val result = try {
    println("Doing some I/O...")
    true
} catch (e: IOException) {
    println("Oops!")
    false
} finally {
    println("""In the "finally" block...""")
}
```

Can you do, `val something = throw IOException()`?

Anyway, yeah:
```
val x = throw IOException()
```
Totally compiles.

And the type of `x` appears to be `Nothing`, at least it still compiles if I explicitly state it as such.

and btw, `while` is a statement, so a while-loop doesn't return anything

`fun justLoop() = while(...) { }` doesn't compile

So, as far as I can tell, in the case of
```
fun justLoop() { while (true) {} }
```
The return type is `Unit`.
It does still compile if I explicitly state return type of `Nothing`.
I'd guess that the compiler would enforce return type of `Nothing` if it were smart enough to know that the function never returns, but I guess it isn't.

If `throw` "returns" `Nothing`, then why doesn't `fun justThrowIt() = throw IOException()` work? Strange.

Well it does "work", in a sense, you're only required to state `Nothing` as the return type, as in
```
fun justThrowIt(): Nothing = throw IOException()
```
That will compile.

<@UBJF87EBY> it does work fine, you get the error *Nothing return type needs to be specified explicitly* so you don't accidentally return `Nothing` from a function