Shouldn't this fail at compilation? or does return...

# getting-started

[Sam]

Shouldn't this fail at compilation? or does return default to false?

val list = listOf( 1, 2, 3, 4, 5 )
    val evenList = list.filter {
        return
        it % 2 == 0
    }

[ValV]

It fails on compilation

[ValV]

return is not allowed there

[Sam]

isn't filter a inline function?

[Sam]

and the lambda that it takes is not marked as crossinline

[ValV]

It is so

[Sam]

it compiles fine for me, the inlined return just returns from the nearest fun (happens to be main in my case )

[ValV]

That lambda travels into if condition inside filterTo function

[Sam]

what kotlin compiler are you using?

[Sam]

yes and filterTo is as well inlined

[ValV]

Kotlin 1.2.71

[ValV]

If it is inlined, so it must look like if (return; it % 2 == 0). Even I would fail here

[Sam]

I'm on 1.2.71 as well, compiles fine

[Sam]

and as expected it just returns from the nearest function

[ValV]

Mayhap, it's another list with some other implementation of filter?

[Sam]

No, it just takes me to the one in stdlib collections

[ValV]

Strange, but it does not compile for me

[Sam]

yeah that is weird

[ValV]

Maybe some annotations that may affect `inline`s?

[Sam]

Try this, what do you get?

inline fun testReturn( block : ()  -> Unit ) {
    block()
}

fun main( argv : Array<String> ) {

    testReturn {
        println( "setup" )
        return
        println( "complete" )
    }
}

[ValV]

Only the last println is unreachable, the rest is fine

[Sam]

yup and the return is a non-local return here

[Sam]

if you remove inline keyword, you should get a compilation error saying "return not allowed here"

[ValV]

Yes, it says so

[Sam]

and that is the same behavior with filter case too

[Sam]

so i'm not sure why you get a compilation error with an inlined filter

[ValV]

BTW, not everywhere, in a clean file it does, trying to figure out why it shows different behavior

[Sam]

hmm, that is strange

[ValV]

Try to put that fragment into a a block, where it will not be able to resolve return, e.g.:

val block = {
   val list = listOf( 1, 2, 3, 4, 5 )
    val evenList = list.filter {
        return
        it % 2 == 0
    }
}

[Sam]

Gotcha

[ValV]

I think that happens, 'cause compiler resolves return of the function outside filter

[Sam]

Here the block could be executed in another context

[Sam]

it is a lambda that could be passed to a thread for instance

fun main( argv : Array<String> ) {

    val block = {
        val list = listOf( 1, 2, 3, 4, 5 )
        val evenList = list.filter {
            it % 2 == 0
        }
        return
        println( evenList )
    }

    thread {
        block()
    }
}

[ValV]

Oh, yes, I used it inside a class

[Sam]

Cool

[ValV]

class MyClass {
  val block = {
    ...
  }
}