Kotlin Any with lambdas

Question

While the code provided with the question is rather trivial, the question focusses on the more general aspect of type safety:

Let's have a lambda function like this:

{it: (Any) -> Any -> it(it)}

It takes another lambda and executes it with itself as a parameter. So let's do the obvious and call it with itself as parameter:

{it: (Any) -> Any -> it(it)}.apply { this.invoke(this) }

But that does not work as well, as I thought: I get the following error at compile time:

Type mismatch: inferred type is ((Any) -> Any) -> Any but (Any) -> Any was expected

Ok. So let's try this one:

val lambda: (Any) -> Any = { Unit }

The actual value of this property doesn't matter, I am not interested in the result, just in the compiler behaviour. So here is another property:

 val kappa: (Any) -> Any = lambda

Ok, now this actually compiles. But isn't that the same thing as before? I am passing a (Any) -> Any function to a property (in the other case it is an argument), that expects a (Any) -> Any function. Logic tells me: Yes, (Any) -> Any is of type Any , because everything is. But why doesn't that work with the lambda invocation? In fact, I can explicitly cast my lambda to a (Any) -> Any function, which will result in an unchecked cast, but it will compile and execution results in a StackOverflowError as expected.

{it: (Any) -> Any -> it(it)}.apply { this.invoke(this as (Any) -> Any) }

Where is the difference?

Answer 1

Ok, there is, as I said in comments, just a whole lot of irrelevant confusion in the way this question is posed. Let's start by cleaning some of it up:

val fn1 = {x1: (Any) -> Any -> x1(x1)}

The type of fn1 is ((Any) -> Any) -> Any . The type of x1 is (Any) -> Any . The definition above compiles. The Kotlin compiler has no trouble seeing that x1 is an Any .

The attempt to invoke fn1 on itself, though, doesn't work. ... and the compiler says exactly why: fn1 is a function that is an ((Any) -> Any) -> Any and cannot be used as an (Any) -> Any . Why doesn't that work? Well, because the somebody might invoke the argument!

So that it is easier to discuss, let's create a second function, very similar to the first:

val fn2 = {x2: (Any) -> Any -> x2("foo")}

It also compiles, just fine. And now this whole question question boils down to:

Why doesn't this work: fn2(fn1)

But it should be obvious, at this point. If that call worked (no matter how much apply or invoke trickery is involved) the attempt to invoke x2 (inside fn2 ) can't work, because x2 is an alias for fn1 . It is a call to fn1 with the argument "foo" , where it expects a function.

tl;dr: Functions are contravariant in their argument types