I'm confused about something. In many places the c...

# announcements

[Emmanuel Oga]

I'm confused about something. In many places the compiler just returns the last thing of a scope, like in lambdas, but sometimes I'm asked to return explicitly by the compiler. What's the rule for returning the last thing in the scope vs requiring an explicit return?

[Emmanuel Oga]

It seems like functions always require the return

[nanodeath]

I think lambda = implicit return, function = explicit return

[Emmanuel Oga]

fun something(num: Int) : Int {
	num + 1
}

fun main() {
    println("Hello, world!!! ${something(1)}")
}

A 'return' expression required in a function with a block body

[nanodeath]

or maybe not even lambda, but like...a block. even if has a value.

[Emmanuel Oga]

I see, seems idiosyncratic ...

[nanodeath]

I guess

[nanodeath]

mainly you want foo?.let { doSomething(it) } and have that have a value

[nanodeath]

but functions are a whole...execution scope. I dunno

[Emmanuel Oga]

howerver:

[nanodeath]

return@ syntax is better in that it's not exactly a return 😄

[Emmanuel Oga]

fun main() {
    val something : (num: Int) -> Int = { num ->
	  num + 1
    }
    println("Hello, world!!! ${something(1)}")
}

[nanodeath]

it's still not a function

[Emmanuel Oga]

so yeah it seems like explicit fun ### will always require a return

[nanodeath]

if we're looking for apparent contradictions, I think you can say

fun addOne(num: Int): Int = run {
  num + 1
}

😛

[Emmanuel Oga]

please no! 😛 haha

[Nir]

I think the reasoning is that basically Kotlin wants lbdas to be concise very badly

[Nir]

Omitting return is key to that

[Nir]

Now, some functional languages don't have return statements at all

[Nir]

But, early returns in longer functions are widely considered really useful and practical

[Nir]

Also really nice in all this is the fact that a lambda passed to an inline function can still return the outer most function

[Nir]

It's a big part of what makes Kotlin DSLs feel like DSLs

[Nir]

Or not even DSLs, just what makes the language so nice to extend with functions taking lambdas. You don't really need to care that you're passing a lambda. It's almost like adding keywords

[Nir]

Anyway I guess just pointing out the reasons and why it all works out nicely, maybe it will seem less idiosyncratic :-). Labelled returns are nice as well.

[Shawn]

@nanodeath that is not a contradiction, just a little ambiguous if you suggest so

[nanodeath]

was just messin' around 😛

[Emmanuel Oga]

thx @Nir that does make a lot of sense