The line `return@tryLambdas` should throw an error...

# announcements

[Suraj Shah]

The line return@tryLambdas should throw an error here right?
It does if i make it return String directly instead of generics.
not sure what is going on here, could this be cause of type erasure?

inline fun T tryLambdas(lamb : () -> T) : T{
    return lamb.invoke()
}

fun main() {
    tryLambdas<String>{
        return@tryLambdas // this should throw an error, but it doesnt. on decompiling it replaces it with Unit.INSTANCE
    }
}

[Karolis]

I think it compiles to tryLambdas<Unit> which is a valid lambda

[Suraj Shah]

yes, even i thought so, but it even accepts String. like i can return return@tryLambdas "some value"

[Karolis]

The type is infered from the lambda. Return value of lambda determines what gets insterted as T

[Karolis]

So if you do return "someString", then T is String. Btw, you can omit return statement, and write just tryLambdasString { "someString" } because result of last lambda's expression is the return value of lambda

[Karolis]

Does that makes sense?

[Suraj Shah]

that's not what my problem is, the problem is i wish to perform a non-local return as well. which it does, but it also allows to return without conforming to the return type specified? which in this case is String. so i can not return a string from a lambda which was specified to return a string. worst, i can return a string or return nothing (unit.)

[Suraj Shah]

are you getting it?

[Karolis]

Do you want to restrict the return type of lambda, or do you want to force tryLambdas to return if you do return from lambda?

[Karolis]

Or is it something else? A more elaborate example would help

[Suraj Shah]

yes, the former. i wish to restrict the lambda to return the type im specifying in T.

[Karolis]

The problem is that you don't specify T, it gets inferred

[Karolis]

tryLambdasString<Unit> { "string" } won't compile. Is this what you want?

[Karolis]

Otherwise, you must specify type in function signature:

inline fun tryLambdas(lamb : () -> Unit) : Unit {
    return lamb.invoke()
}

[Karolis]

Or, you could restrict T, e.g.

inline fun <T: String> tryLambdas(lamb : () -> T) : T{
    return lamb.invoke()
}

tryLambdas {
    5 // does not compile, must be a String
}

[Suraj Shah]

but it might not always be a String or a Unit or something that extends a String.

[Suraj Shah]

there was a typo in the original question, my bad, ive updated it.

[Karolis]

I don't know of a way to restrict type without restricting it

[Suraj Shah]

so,

tryLambdas<String> {
 // allows both
return@tryLambdas "string"
// and this, which is unit, 
return@tryLambdas 
}

even though im specifying T as String

[Suraj Shah]

the latter one, which is just return@tryLambdas should throw an error right? the lambda should expect a String.

[Karolis]

Yeah, you're right, it should not compile

[Karolis]

It's a bug in new compiler type inferrence. It would be nice if you reported it

[Suraj Shah]

okay. i'll do it. thanks.

[Karolis]

For now, you can disable the new compiler by unchecking the checkbox Enable new type inference ..., as shown in the screenshot

[Suraj Shah]

let me try. give me a moment.

[Suraj Shah]

yes it works. seems like a bug. good catch. i'll report it.

[Karolis]

👍

[Suraj Shah]

thanks @faisalahmed for the tip.

[Suraj Shah]

issue link: https://youtrack.jetbrains.com/issue/KT-32792