You have a property `val onClick: (() -> Unit)?`. How do you call it safely when it might be null, and what is the difference between `onClick?.invoke()` and `onClick()`?
answer
- `?.invoke()` is the safe call form
- `f()` desugars to `f.invoke()` — needs non-null receiver
- Parens: `(() -> Unit)?` vs `() -> Unit?`
- var member can't smart-cast → must use ?.invoke()
- result type is `Unit?`
basics
~10 sUse onClick?.invoke(). It runs the function only if it is not null, otherwise it does nothing. Calling onClick() directly would not compile because the type may be null.
solid answer
~40 sA nullable function type like `(() -> Unit)?` cannot be invoked with normal call syntax `onClick()` because the call operator is not defined on a nullable type — the compiler rejects it. You must first deal with the null. The idiomatic way is the safe-call form `onClick?.invoke()`, which only calls `invoke` when the reference is non-null and otherwise evaluates to `null` (or `Unit?`). The parentheses-call sugar `onClick()` desugars to `onClick.invoke()`, and `.invoke` requires a non-null receiver. Alternatives: a null check (`if (onClick != null) onClick()` with a smart cast, only for `val`/locals), or `onClick?.let { it() }`. For a default, `(onClick ?: {})()` substitutes an empty lambda.
code
kotlin · 11 linesclass Button(var onClick: (() -> Unit)? = null) {
fun click() {
// onClick() would NOT compile (nullable, and var can't smart-cast)
onClick?.invoke()
}
}
val b = Button { println("clicked") }
b.click() // prints "clicked"
b.onClick = null
b.click() // does nothing, no NPEgo deeper
Knows to use onClick?.invoke() and that direct onClick() won't compile on a nullable type.
Explains f() desugars to .invoke(), the Unit? result type, and offers let/elvis alternatives.
Articulates the smart-cast limitation on mutable member vars and the thread-safety reasoning behind it.
Discusses API design — when to model an absent callback as nullable vs a no-op default lambda, and the ergonomics/perf trade-offs.
## What a nullable function type is A **function type** describes a value you can call, e.g. `() -> Unit`, `(Int) -> Int`, `(String, Int) -> Boolean`. Adding `?` makes it **nullable**: `(() -> Unit)?` means "either a function taking no args returning Unit, OR null". The parentheses around the function type are required so the `?` applies to the whole function type and not just the return type — `() -> Unit?` is a function returning a nullable `Unit`, which is different. ## Why `onClick()` does not compile In Kotlin, the call syntax `f(args)` is sugar for `f.invoke(args)`. `invoke` is an **operator function** defined on (non-null) function types. On a nullable receiver you cannot call a member/operator directly, so `onClick()` is a compile error: *"Reference has a nullable type '(() -> Unit)?', use explicit '?.invoke()' to make a function-like call instead."* ## Safe ways to call it ```kotlin val onClick: (() -> Unit)? = null // 1. Safe call on invoke — most idiomatic onClick?.invoke() // 2. let onClick?.let { it() } // 3. Null check + smart cast (only val / local, not var properties) if (onClick != null) onClick() // 4. Elvis with a no-op default, then call (onClick ?: {})() ``` - `onClick?.invoke()` evaluates to `Unit?`: `Unit` if called, `null` if skipped. - The smart-cast form `if (onClick != null) onClick()` works only when the compiler can prove the value will not change between the check and the call — true for a local `val` or an immutable property, but **not** for a mutable `var` member property (it could be changed by another thread), where you must use `?.invoke()` or copy into a local first. ## Passing arguments For `val transform: ((Int) -> Int)?`, you pass args inside invoke: `transform?.invoke(5)`.
- Why does `if (onClick != null) onClick()` fail to compile when `onClick` is a `var` member property?Smart casts require the value can't change after the check; a mutable member `var` could be reassigned (e.g. by another thread) between check and call, so the compiler refuses to smart-cast it to non-null. Copy to a local val or use `?.invoke()`.
- What is the type of the expression `onClick?.invoke()`?`Unit?` — it is `Unit` when the function ran and `null` when the receiver was null, because `?.` makes the whole expression nullable.
Like dialing a phone number that might be empty — ?.invoke() checks there's a number before dialing.
saying these in an interview costs you the question
- Claiming `onClick()` works directly on a nullable function type
- Saying `?.invoke()` throws if null (it does not — it skips)
- Forgetting the parentheses distinction `(() -> Unit)?` vs `() -> Unit?`
- Insisting smart cast works on a mutable `var` member property
- Calling `onClick!!.invoke()` as the normal/safe approach