Kotlin typealias

The typealias can be handy to define very simple types. But be aware that it is not represented in bytecode. The typealiases are simply replaced by the type they represent and so can't be used for function signatures. See also Type aliases


By using typealiases code can become fuzzy very quickly. Especially when using typealiasses in typealiasses.

Bean injection is first done based on name but if that fails it is done based on type. But when using typealiasses the type is not clear when looking at the code. Unexpected results might arrise when the named bean is renamed and there is only one alternative based on type. Then that other bean is silently injected.


See some examples below

import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.context.annotation.Bean

typealias TypeOne = String
typealias TypeTwo = String

typealias SignatureOne = () -> String
typealias SignatureTwo = () -> String

class ExperimentMilo {
class TestConfig {
fun funOne(): SignatureOne = { "FunOne" }

fun funTwo(): SignatureTwo = { "FunTwo" }

// Those are resolved based on the name of the bean. The variable name is exactly
// the same as the bean name
@Autowired lateinit var funOne: SignatureOne
@Autowired lateinit var funTwo: SignatureTwo

// Those can't be resolved based on the name and so are resolved based on the type.
// This would give an error because there are multiple beans with the same type.
// By using 'Qualifiers' we force the specific bean.
@Autowired @Qualifier("funOne") lateinit var functionOne: SignatureOne
@Autowired @Qualifier("funTwo") lateinit var functionTwo: SignatureTwo

fun testBeanSignature() {
val resultOne = funOne.invoke()
val resultTwo = funTwo.invoke()

Assertions.assertEquals("FunOne", resultOne)
Assertions.assertEquals("FunTwo", resultTwo)

fun testBeanSignature2() {
val resultOne = functionOne.invoke()
val resultTwo = functionTwo.invoke()

Assertions.assertEquals("FunOne", resultOne)
Assertions.assertEquals("FunTwo", resultTwo)

fun testFunctionSignature() {
val one: TypeOne = "One"
val two: TypeTwo = "Two"

val resultOneTwo = testSignature(one, two)
val resultTwoOne = testSignature(two, one)

Assertions.assertEquals(Pair("One", "Two"), resultOneTwo)
Assertions.assertEquals(Pair("Two", "One"), resultTwoOne)

fun testSignature(one: TypeOne, two: TypeTwo): Pair<TypeOne, TypeTwo> {
return Pair(one, two)