Type inference for higher order functions with generic return types

Question

The following example is perfectly legal in Kotlin 1.3.21:

fun <T> foo(bar: T): T = bar

val t: Int = foo(1) // No need to declare foo<Int>(1) explicitly

But why doesn't type inference work for higher order functions?

fun <T> foo() = fun(bar: T): T = bar

val t: Int = foo()(1) // Compile error: Type inference failed...

When using higher order functions, Kotlin forces the call site to be:

val t = foo<Int>()(1)

Even if the return type of foo is specified explicitly, type inference still fails:

fun <T> foo(): (T) -> T = fun(bar: T): T = bar

val t: Int = foo()(1) // Compile error: Type inference failed...

However, when the generic type parameter is shared with the outer function, it works!

fun <T> foo(baz: T) = fun (bar: T): T = bar

val t: Int = foo(1)(1) // Horray! But I want to write foo()(1) instead...

How do I write the function foo so that foo()(1) will compile, where bar is a generic type?

Answer 1

I am not an expert on how type inference works, but the basic rule is: At the point of use the compiler must know all types in the expression being used.

So from my understanding is that:

foo() <- using type information here

foo()(1) <- providing the information here

Looks like type inference doesn't work 'backward'

    val foo = foo<Int>()//create function
    val bar = foo(1)//call function