Is using function references in any way different than wrapping calls in lambdas? For example with

fun doSomething(param: String)
fun foo(param: String) 

foo { doSomething(it) }
vs
foo(::doSomething)
vs
foo(instance::doSomething)

is bytecode for either option more efficient for example?

the parser might do less work, but not likely any benefit

For some reason I thought there might be, perhaps only on some JVM targets. Or maybe only on Android with R8 optimizations?

Kotlin doesn't have AOP, i don't think there is any way to make the variations mean unseen things.

There are a couple of differences to watch out for. For example:

var string: String = "a"
val f1: () -> Int = { string.length }
val f2: () -> Int = string::length
println(f1())  // 1
println(f2())  // 1
string = "aaa"
println(f1())  // 3
println(f2())  // 1

That’s right, I also got a NPE once because the receiver wasn’t yet initialized, too. So it does change something, but function reference still creates the same lambda as writing it manually?