Kotlin - Functional (SAM) interfaces VS Function types

Question

With Kotlin 1.4 we now have Functional Interfaces

fun interface Todo {
       fun run()
}

fun runBlock(todo: Todo){
   if(condition)
      todo.run()

}

fun runBlock{
   println("Hello world")
}

Before i was always using (T) -> T

inline fun runBlock(block: ()-> Unit){
   if(condition)
      block()
}

fun runBlock{
   println("Hello world")
}

So basically I can make the same task with both methods , there is any performance advantage by using Functional SAM() Interfaces over Function Type?.

Answer 1

https://kotlinlang.org/docs/reference/whatsnew14.html#sam-conversions-for-kotlin-interfaces

the compiler automatically converts the lambda to an instance of the class that implements the abstract member function.

So, no performance advantage, it’s the same thing as before. The compiler now does what you had to do before.

Answer 2

As other answers and comments have pointed out, in your case, using inlined lambda is faster, since there is no function call overhead when invoking it.

However, there is one specific use case where using SAM interface is faster, that is when you 1. do not inline the lambda and 2. the arguments/return value of the lambda is a primitive (or any other type that may cause boxing when used with generics).

For example, using SAM interface like so:

fun interface Foo() {
    fun run(i: Int): Int
}

fun foo(fn: Foo) {
    fn.run(42)
}

foo { it * 2 }

Will not cause any boxing when invoked, while:

fun foo(fn: (Int) -> Int) {
    fn(42)
}

foo { it * 2 }

Will box the integer argument since (Int) -> Int is essentially Function1<Integer, Integer> in Java, which uses generic.