How to understand when I can use a Kotlin anonymous function?

Issue

I'm struggling with Kotlin anonymous functions. The syntax seems to vary (sometimes parenthesis are used, sometimes not) and I'm not sure where they can vs. cannot be used.

In this code for example, what exactly is the anonymous function replacing? It just seems to suddenly pop up in the middle of a builder and it's not at all clear what it's doing.

// Choose between gallery and camera
val builder = AlertDialog.Builder(this)
val sources = arrayOf("Use Camera", "View Gallery")
builder.setItems(sources) { _, which ->
    when (which) {
        0 -> { cameraIntentLauncher.launch(cameraIntent) }
        1 -> { galleryIntentLauncher.launch(galleryIntent) }
        }
    }.create().show(). 

Is it associated with setItems()? Not really. It appears to be defining the callback function that occurs after an item is selected. But there's no ".setCallback()" to attach it to the builder.

In regular Java, I'd expect something like:

builder.setItems(sources, new callbackFunc {...})

But in the above Kotlin, the anonymous function is defined outside of the setItems() parenthesis. It's very confusing.

So what can I read or watch to understand this Kotlin syntax implicitly when reading it?

Solution

The concept used here is called Trailing lambdas.

According to Kotlin convention, if the last parameter of a function is a function, then a lambda expression passed as the corresponding argument can be placed outside the parentheses

So your code,

builder
    .setItems(sources) { _, which ->
        when (which) {
            0 -> {
                cameraIntentLauncher.launch(cameraIntent)
            }
            1 -> {
                galleryIntentLauncher.launch(galleryIntent)
            }
        }
    }
    .create()
    .show()

And the below code would be considered as same.

builder
    .setItems(sources, { _, which ->
        when (which) {
            0 -> {
                cameraIntentLauncher.launch(cameraIntent)
            }
            1 -> {
                galleryIntentLauncher.launch(galleryIntent)
            }
        }
    })
    .create()
    .show()

Adding more details as suggested in the comments.

If the lambda is the only argument in that call, the parentheses can be omitted entirely.

Example

run { println("...") }

Lambdas and anonymous functions are not the same.

• Difference in return type
  The return type inference for anonymous functions works just like for normal functions: the return type is inferred automatically for anonymous functions with an expression body, but it has to be specified explicitly (or is assumed to be Unit) for anonymous functions with a block body.

• Difference in return statement
  A difference between lambda expressions and anonymous functions is the behavior of non-local returns.
  A return statement without a label always returns from the function declared with the fun keyword.
  This means that a return inside a lambda expression will return from the enclosing function, whereas a return inside an anonymous function will return from the anonymous function itself.

When passing anonymous functions as parameters, place them inside the parentheses. The shorthand syntax that allows you to leave the function outside the parentheses works only for lambda expressions.

Answered By - Abhimanyu