Reified sa Kotlin — ano ito, syntax at aplikasyon

Ano ang reified sa Kotlin?

reified — ay isang modifier ng generic parameter ng inline-function na nagpapaging tunay sa uri (reify — “gawing tunay”) sa runtime. Kung walang reified, ang uri T sa loob ng generic function ay hindi maa-access — inilalapat ng compiler ang type erasure, binubura ang lahat ng impormasyon tungkol sa uri. reified pinipilit ang compiler na palitan ang konkretong uri sa lugar ng tawag, ginagawa itong accessible sa pamamagitan ng T::class at operator is.

Ayon sa Kotlin Survey by Kodee (2024), ang reified type parameters ay kabilang sa sampung pinaka-hinahanap na feature ng Kotlin — 52% ng mga na-survey na developer ay gumagamit ng mga ito, pangunahin para sa pagsulat ng generic-factory, DI-container, at serializer. Lalo na sikat ang reified kasama ng Gson, Moshi, at Kotlinx Serialization.

Sa teknikal na paraan, simple ang mekanismo: kapag tumatawag ng inline-function na may reified parameter, alam ng compiler ang konkretong uri ng argument (Int, String, User) at pinapalitan ito sa lugar ng T. Sa bytecode, ang reified-parameter ay nagiging ordinaryong Class, na ipinapasa bilang nakatagong argumento.

Gamitin ang reified para sa pagsulat ng generic function kung saan kailangan ang uri sa runtime — paglikha ng instance, pagsusuri ng uri, pagkuha ng Class para sa reflection o serialization.

Problema ng type erasure sa generic

Type erasure — mekanismo ng Java at Kotlin kung saan ang impormasyon tungkol sa generic na parameter ay binubura sa panahon ng compilation. Sa bytecode, ang List at List ay nagiging List na lang. Ito ay ginawa para sa backward compatibility sa Java 1.4, kung saan wala pang generic, ngunit lumilikha ng mga limitasyon kapag nagtatrabaho sa mga uri sa runtime.

// ❌ Error: Hindi masusuri ang instance ng binurang uri
fun <T> checkType(value: Any) {
    if (value is T) { // type erasure — hindi alam ang T
        println("Tugma ang uri")
    }
}

// ✅ Solution: pass Class as parameter
fun <T> checkTypeWithClass(
    value: Any,
    clazz: Class<T>
) {
    if (clazz.isInstance(value)) {
        println("Tugma ang uri")
    }
}

Sa halimbawa, ang checkType ay hindi nagko-compile dahil sa type erasure — hindi alam ng compiler kung anong uri ang papalit sa T. Sa checkTypeWithClass, nalutas ang problema sa pamamagitan ng explicit na pagpasa ng Class, ngunit ito ay nangangailangan ng boilerplate: bawat tawag ay sinamahan ng .java o ::class.java. Ganap na inaalis ng reified ang boilerplate na ito.

Syntax ng reified at mekanismo ng trabaho

Ang modifier na reified ay inilalagay bago ang generic parameter sa isang inline-function. Ang function ay dapat na inline — ang compiler ay dapat magkaroon ng kakayahang palitan ang konkretong uri sa yugto ng inlining.

inline fun <reified T> isA(value: Any): Boolean {
    return value is T
}

fun main() {
    println(isA<String>("Kumusta")) // true
    println(isA<Int>("Kumusta"))  // false
}

Sa panahon ng compilation, ang tawag na isA("Hello") ay pinapalitan ng pagsusuri na value is String. Ang tawag na isA("Hello") — ng value is Int. Ang uri ay literal na pinapalitan, na nagbibigay-daan sa paggamit ng is, as, ::class, at iba pang operasyon na hindi available sa type erasure.

Decompilation ng reified function

Kung ide-decompile natin ang bytecode ng isA("Hello"), ipapakita ng IntelliJ IDEA ang humigit-kumulang sumusunod na resulta sa Java: String.class.isInstance(value). Sa halip na generic parameter, pinalitan ng compiler ang konkretong java.lang.String.class — walang reflection na may paghahanap ng uri sa pangalan, direktang reference lamang sa klase.

Mga pagsusuri ng uri gamit ang reified: is at as

Ang pinakakaraniwang aplikasyon ng reified — pagsusuri ng uri sa pamamagitan ng operator na is. Sa ordinaryong generic function, ang value is T ay hindi nagko-compile. Sa reified, ito ay gumagana tulad ng sa ordinaryong klase: value is String, value is List (halos — isinasaalang-alang ang mga limitasyon ng reified para sa mga parameterized na uri).

inline fun <reified T> List<Any>.filterByType(): List<T> {
    return this.filter { it is T }.map { it as T }
}

val mixed = listOf("a", 1, "b", 2)
val strings = mixed.filterByType<String>() // ["a", "b"]
val ints = mixed.filterByType<Int>()    // [1, 2]

Ang extension function na filterByType ay nagfi-filter ng listahan, nag-iiwan lamang ng mga elemento ng tinukoy na uri. Kung walang reified, kailangan isulat ang filterByType(list) na may parameter na Class. Sa reified, ang tawag ay binabasa bilang natural na operasyon sa listahan, na nagpapabuti sa pagiging nababasa ng mga chain ng pagproseso ng data.

Ayon sa datos Kotlin Coroutines Guide (JetBrains, 2025), ang mga reified type check ay ginagamit sa launch at async para sa pagpasa ng uri ng resulta ng coroutine, na nagpapahintulot na maiwasan ang explicit na pagtukoy ng uri sa karamihan ng mga kaso.

Reflection gamit ang reified: paglikha ng instance at access sa Class

Ang reified ay nagbibigay ng access sa T::class — reference sa KClass, kung saan maaaring makuha ang Java Class sa pamamagitan ng .java. Nagbubukas ito ng mga posibilidad para sa paglikha ng instance sa pamamagitan ng reflection, pagtatrabaho sa mga serializer, at pagkuha ng mga annotation ng klase sa panahon ng pagpapatupad.

inline fun <reified T> createInstance(): T =
    T::class.java.getDeclaredConstructor().newInstance()

// Paggamit
data class User(val name: String = "default")
val user = createInstance<User>()

// Serialization gamit ang Gson
inline fun <reified T> Gson.fromJson(json: String): T =
    this.fromJson(json, T::class.java)

// Pagkuha ng mga annotation
inline fun <reified T> hasAnnotation<A>(): Boolean where A : Annotation =
    T::class.java.isAnnotationPresent(A::class.java)

Ang wrapper na fromJson para sa Gson — klasikong halimbawa ng paggamit ng reified sa produksyon. Sa halip na gson.fromJson(json, User::class.java) ay maaaring isulat ang gson.fromJson(json). Ito ay tila isang maliit na pagpapabuti, ngunit sa isang proyekto na may daan-daang tawag ng serialization, ang reified ay makabuluhang nagbabawas ng boilerplate at ginagawang mas malinis ang code.

Mga limitasyon ng reified at mga alternatibo

Ang reified ay may mga limitasyon. Una — gumagana lamang sa loob ng inline-function. Kung ang function ay hindi maaaring gawing inline (halimbawa, recursive o masyadong malaki), hindi available ang reified. Pangalawa — ang reified ay hindi maaaring gamitin nang direkta sa suspend-function, sa pamamagitan lamang ng inline wrapper.

Pangatlo — ang reified ay hindi ganap na gumagana sa mga parameterized na uri. Halimbawa, ang filterByType>() ay maaaring magbigay ng hindi inaasahang resulta, dahil para sa mga parameterized na uri, ang reified ay nagpapanatili lamang ng raw type (List), nang hindi tinutukoy ang mga generic na argumento. Para sa kumpletong pagsusuri ng mga parameterized na uri, kinakailangan ang reflection gamit ang TypeToken.

Para sa mga kaso kung saan hindi available ang reified, gamitin ang pattern na may explicit na pagpasa ng Class o TypeToken mula sa mga library (halimbawa, Gson TypeToken o Jackson TypeReference). Ang approach na ito ay gumagana sa anumang function, ngunit nangangailangan ng boilerplate at hindi gaanong maginhawa.