Any significant differences between lambda expressions & anonymous function in Kotlin?

Question

Kotlin has these 2 features and I think there're no significant differences between these two regardless of :

syntax

// lambda
val toUpper = { value: String -> 
   if (value.isEmpty()) "empty value"
   else value.toUpperCase()
}

// anonymous func
val toUpper = fun(value: String): String {
  if (value.isEmpty()) return "empty value"
  else return value.toUpperCase()
}

flexibility to use return statement on anonymous function

I'm still digesting these features and hope you guys can help me pass through it. Thanks.

It seems same to me, just like how `A.() -> B` is same as `(A) -> B` in bytecode (both are `KFunction1`) but inside syntax is different `A.() -> B` lets you have `this` as receiver while `(A) -> B` lets you have variable of any name. Similarly `(String) -> String` can be assigned to both of them, i.e. fun one is also an implementation of `KFunction1`. — Animesh Sahu, Jul 02 '20 at 05:25
See also: https://stackoverflow.com/questions/58004914/kotlin-fun-vs-lambda-is-there-difference/, https://stackoverflow.com/questions/43166375/kotlin-anonymous-function-use-case — Alexey Romanov, Jul 02 '20 at 07:56
Does this answer your question? [Kotlin fun() vs lambda is there difference?](https://stackoverflow.com/questions/58004914/kotlin-fun-vs-lambda-is-there-difference) — Tenfour04, Jul 02 '20 at 14:00
@KelvinM did my answer resolve your question? If so please accept the answer :) — beastlyCoder, Jul 02 '20 at 20:23

score 3 · Answer 1 · answered Jul 02 '20 at 04:40

3

Two differences according to Kotlin Reference:

(I think the more significant one out of the two) An anonymous function is still a function, so returning from it behaves the same as returning from any function. Returning from a lambda, however, actually returns from the function enclosing the lambda.
The return type of a lambda is inferred, while you can explicitly specify a return type for an anonymous function.

answered Jul 02 '20 at 04:40

jingx

3,698
3
24
40

I think lambda's return type can be specified too, like val toUpper: (String) -> String { } – Kelvin M Jul 02 '20 at 06:57
Kelvin M, that's not specifying the type of the lambda; it's specifying the type of variable you're assigning it to. In your example the effect is the same — but it's not if the lambda is used as a function parameter or in a more complex expression. – gidds Jul 02 '20 at 07:27

score 0 · Answer 2 · answered Jul 02 '20 at 04:16

This website states: "Lambdas Expressions are essentially anonymous functions that we can treat as values – we can, for example, pass them as arguments to methods, return them, or do any other thing we could do with a normal object." (link)

So the answer is no, there isn't a difference between the two, they are interchangeable. Both of the codes you show above, will in the end return the same value to that variable

score 0 · Answer 3 · answered Jul 28 '22 at 03:09

Besides the differences pointed by @jingx, you can not local return from a lambda that is not inlined.

So, the next snippet will not compile unless you add inline to the extension() function, thus, instructing the compiler to copy the function's content whenever it is referenced:

fun doSomethingWithLambda(){
    10.extension{
        if(it == 10)
            return//compiler error
    }
    println("hello")
}

fun Int.extension(f: (Int)->Unit){
    f(this)
}

Any significant differences between lambda expressions & anonymous function in Kotlin?

3 Answers3