Hello kotliners,

fun main() {
    fun fun1(name: String) = println("Hello $name")
    val fun2 = { name: String -> println("Hello $name") }
    function(::fun1)
    function(fun2)
}

fun function(callback: (name: String) -> Any) {
    //some complicated calculation
    callback("username")
}

Which one would you use, and why?

if there was a reason it couldn't be called directly, such as

val name: String?

, then I would generally prefer

fun fun1(name: String)
name?.let { fun1(it) }

over

?.run

or

::fun1

or

val fun1

this is a simplified example of a more complicated use-case, I call a function with lambda parameters, and I pass in the local function using a reference (::). I am editing my original question to illustrate that

my opinion: very strongly prefer

fun fun1()

over

val fun1 = {}

. weakly prefer

function { fun1(it) }

over

function(::fun1)

I don't have too much experience with bytecode, but here is a comparison if someone more experienced would like to weigh in: fun1 declaration:

L0

LINENUMBER 7 L0

GETSTATIC Test$test1$1.INSTANCE : LTest$test1$1;

ASTORE 1

fun1 invocation:

L1

LINENUMBER 8 L1

ALOAD 0

GETSTATIC Test$test1$2.INSTANCE : LTest$test1$2;

CHECKCAST kotlin/jvm/functions/Function1

INVOKEVIRTUAL Test.func (Lkotlin/jvm/functions/Function1;)V

fun2 declaration:

L0

LINENUMBER 13 L0

GETSTATIC Test$test2$fun2$1.INSTANCE : LTest$test2$fun2$1;

CHECKCAST kotlin/jvm/functions/Function1

ASTORE 1

fun2 invocation:

L1

LINENUMBER 14 L1

ALOAD 0

ALOAD 1

INVOKEVIRTUAL Test.func (Lkotlin/jvm/functions/Function1;)V

looks like func1 has an extra GETSTATIC in the invocation phase also, regarding your comment on function { func1(it) } vs. function(::func1) - it appears they are bytecode-equivalent, apparently just syntactic sugar overall, looks to me like a matter of personal preference and code styling

not 100% bytecode equivalent - the wrapper lambda class generated for

::func1

has some different metadata and serializability than

{ func1(it) }

- but close enough

You shouldn't compare bytecode to find the better of two constructs. Byte code is not part of the API, it could change anytime. Also that would not even be micro-optimization which you should avoid already, but nano-optimization. 80% of the runtime of a program is spent in 20% of the code and there is not much point in optimizing the other 80%. 1. Make your code work (optimally with tests, especially for the latter steps) 2. Make your code nice by refactoring 3. If you then have an actual measured performance or memory problem, optimize exactly there.

my concern when posting this was with your 2nd clause "Make your code nice" - first I wanted to make sure I was not overlooking functionality, and then get feedback on which syntax is more likeable, or agreed upon, by other people

Sure, just mentioning in general as you said you looked at the bytecode. 🙂

You still haven't answered the original question though, which one would you rather use?

Well, I don't have much to add what the others said. It depends on the situation.

IMHO I would use

function(::fun1)

cause it much more clear that it is a callback , than

function(fun2)

however a closure is more powerful cause you can combine closures

function(fun2.then(fun3))

Actually there is no such thing as a Closure in Kotlin, it is a lambda expression. Closure is a term from other language like Groovy. 😉