What is a function-type alias in Kotlin, and how would you declare an alias named Handler for a function that takes an Event and returns Unit?
answer
- typealias = nickname, not a new type
- (Event) -> Unit is the function type
- top-level only, no runtime object
- compiler expands alias back to the real type
- interchangeable with the raw arrow type
basics
~10 sIt gives a short, readable name to a function type. You write typealias Handler = (Event) -> Unit. Then you can use Handler anywhere instead of writing the long (Event) -> Unit signature.
solid answer
~40 sA function-type alias uses the `typealias` keyword to name a function type so the long lambda signature reads clearly at use sites. Declaration: `typealias Handler = (Event) -> Unit`. After that, parameters, properties and return types can be typed as `Handler` instead of `(Event) -> Unit`. It is purely a compile-time, top-level naming convenience: the compiler expands `Handler` back to `(Event) -> Unit`, so a `Handler` and a raw `(Event) -> Unit` are the same type and interchangeable, with no runtime object or wrapper created. Aliases must be declared at file/top level (not inside a function or class body). They are great for callback signatures, comparators, and event handlers where the bare arrow syntax would otherwise repeat and obscure intent.
code
kotlin · 11 linestypealias Handler = (Event) -> Unit
class EventBus {
private val handlers = mutableListOf<Handler>()
fun subscribe(handler: Handler) { handlers += handler }
fun publish(event: Event) { handlers.forEach { it(event) } }
}
// A raw (Event) -> Unit is accepted because it IS the same type:
val raw: (Event) -> Unit = { e -> println(e) }
EventBus().subscribe(raw)go deeper
Can write typealias Handler = (Event) -> Unit and use it as a parameter type.
Knows it is a compile-time alias interchangeable with the raw function type and has no runtime cost.
Explains the no-extra-type-safety consequence and contrasts with fun interface / value class for nominal types.
Frames aliases as API-readability tooling and decides when nominal typing (real type) is warranted over an alias in a public contract.
## What a function-type alias is A **type alias** is an alternative name for an existing type, introduced with the `typealias` keyword. A **function-type alias** specifically names a *function type* — a type written with the arrow syntax `(Params) -> ReturnType`. Kotlin function types look like `(Event) -> Unit`, `(Int, Int) -> Int`, or `suspend () -> String`. When these signatures appear repeatedly (callbacks, listeners, comparators) they become noisy. A typealias gives them a domain name: ```kotlin typealias Handler = (Event) -> Unit fun register(onEvent: Handler) { /* ... */ } val h: Handler = { event -> println(event) } register(h) register { event -> println(event) } // lambda literal works too ``` ## Key properties - **`typealias` is top-level only.** It must be declared at file scope (or inside an object/companion as a member in newer versions), *never* inside a function body. - **It is a pure compile-time alias, not a new type.** The compiler erases `Handler` to `(Event) -> Unit`. So `Handler` and `(Event) -> Unit` are the *same* type; you can pass one where the other is expected with no conversion. This is unlike an `inline value class` wrapper, which *is* a distinct type. - **No runtime cost / no wrapper object.** Nothing is allocated; there is no `Handler` class in the bytecode. - **Receiver and suspend forms are supported.** You can alias `typealias Click = View.() -> Unit` (function type *with receiver*) or `typealias AsyncOp = suspend () -> Result`. ## Why use them - Readability at call sites and in public APIs. - A single place to change a callback signature. - Self-documenting names (`Validator`, `Reducer`, `Comparator`-like types). ## Limitations Because it is not a real type, a function-type alias gives **no extra type safety** — you cannot distinguish two aliases of the *same* underlying function type, and you cannot overload solely by alias name. For nominal distinctness you need a real class or a functional interface (`fun interface`).
- Can you declare a typealias inside a function body?No. Type aliases must be declared at the top (file/class) level; declaring one inside a function is a compile error.
- Does Handler create a new runtime type you can check with `is Handler`?No. It expands to `(Event) -> Unit` at compile time, so `is Handler` is just `is Function1<Event, Unit>`; there is no distinct Handler class.
Like a contact nickname in your phone: 'Mom' and the real phone number are the same number, just easier to read.
saying these in an interview costs you the question
- Saying typealias creates a brand-new distinct type with its own runtime class
- Claiming it adds type safety so two aliases of the same type can't be mixed
- Thinking a typealias allocates a wrapper object at runtime
- Trying to declare the alias inside a method body
- Confusing typealias with a `fun interface` or `value class`