What’s Trailing Lambda and Comma in Kotlin?

Trailing lambda and trailing comma are the two essential Kotlin options that it’s essential to know should you’re new to Kotlin!

This text was initially printed at vtsen.hashnode.dev on Aug 6, 2022.

Trailing lambda is one thing new in Kotlin that different programming language would not have. A minimum of, I don’t conscious of some other programming language that helps it.

While you see code like this:

var outcome = operateOnNumbers(a, b) { input1, input2 ->
    input1 + input2
}
println(outcome)

It principally means operateOnNumbers() has 3 parameters. The final parameter is a operate definition, which you normally both move within the operate reference or lambda.

var outcome = operateOnNumbers(
    input1 = a,
    input2 = b,
    operation = { input1, input2 ->
        input1 + input2
    }
)
println(outcome)

One way or the other I’m nonetheless not getting used to this trailing lambda syntax. It seems to be like a operate implementation.

So my thoughts all the time must routinely map to this (the code outdoors the parentheses is definitely the final parameter of the operate) each time I see the Trailing Lambda syntax.

The signature and implementation of operateOnNumbers() seems to be like this:

enjoyable operateOnNumbers(
    input1: Int,
    input2: Int,
    operation: (Int, Int) -> Int): Int {

    return operation(input1, input2)
}

Then again, trailing commas is fairly widespread in different language.

** With Trailing Comma**

var outcome = operateOnNumbers(
    a, 
    b, // trailing comma right here
) { input1, input2 ->
    input1 + input2
}

** With out Trailing Comma**

var outcome = operateOnNumbers(
    a, 
    b // no trailing comma right here
) { input1, input2 ->
    input1 + input2
}

The good thing about utilizing it’s permitting simpler diff and merge. For me, it makes my copy and paste life simpler. Yupe, I do lots of copy & paste!

Conclusion

I hope you take pleasure in this brief submit. I need to weblog about this (particularly Trailing Lambda) as a result of it typically seems to be complicated to me, particularly the operate name is a bit advanced. I all the time have to remind myself, the code outdoors the parentheses is definitely the final parameter of the operate.

See Additionally