How do I idiomatically call a nullable lambda in Kotlin?

Given the following lambda:

val lambda: () -> Unit = null

Which of the following calls is idomatic to Kotlin for calling a nullable lambda?

lambda?.let { it() }

vs

lambda?.invoke()

Let's ask Kotlin compiler:

val lambda: (() -> Unit)? = null
lambda()

Compilers says:

Reference has a nullable type '(() -> Unit)?', use explicit '?.invoke()' to make a function-like call instead

So yeah, seems that `?.invoke()` is the way to go.

Although even this seems fine by me (and by compiler too):

if (lambda != null) {
lambda()
}

Here is a simple example:

fun takeThatFunction(nullableFun: (() -> Unit)?) {
nullableFun?.let { it() }
}

takeThatFunction { print("yo!") }

An alias on this case could be a more expressive approach

```
typealias TheNameOFYourCallback = ()-> Unit

class Something {

private var callback: TheNameOFYourCallback? = null

fun setTheCallback(callback: TheNameOFYourCallback) {
this.callback = callback
}

private fun usageOfCallback() {
callack?.invoke()
}

}
```

And then for using

```
val something = Something()
something.setTheCallback {
//Do your thing
}
```

Off course, the `var` could have been not `private` but in this way setting the callback can take advantage of the syntactic sugar of lambdas for methods, otherwise, the assignation form seems odd to me, judge by your self:

```
something.callback = {
//Do your thing
}
```