What is better approach of callback in Kotlin? Listener vs High-Order function [closed]

Question

Please explain a use cases and pros and cons of each approach.

1. Use of interface.

   fun doSomethingWithCallback(callback: Callback) {
       // Do something
       callback.call()
   }
   

2. Use of high-order function.

   fun doSomethingWithCallback(callback: () -> Unit) {
       // Do something
       callback()
   }
   

Answer 1

Option 1

With option 1 you're not able to call it passing a lambda. For example this does not compile:

doSomethingWithCallback1 { print("helloWorld") }

Interestingly if the same method were defined in Java:

void doSomethingWithJavaCallback(JavaCallback callback) {
    // Do something
    callback.call();
}

Then you can call it using a lambda from Kotlin. This is because Kotlin only does SAM-conversion for functions defined in Java.

Option 2

In contrast if you go with option 2 you do get to call it using a lambda. And it will work both when calling it from Kotlin and from Java.

Option 3

As mentioned in the comments a third option is using a type alias like this:

typealias Callback = () -> Unit

fun doSomethingWithCallback5(callback: Callback) {
    // Do something
    callback()
}

You get to keep the type in the function signature and use lambdas on the call site.

Answer 2

1. You can use with a lambda :

      doSomethingWithCallback { // do whatever you want }
   

2. I usually use lambda function by this one:

   var doSomething: ((Any) -> Unit)? = null

and invoke callback:

    doSomething?.invoke(any)

finally as same as listener:

    youClass.doSomething = { any ->
        // this is callback
    }