Typealias — ano ito, syntax at aplikasyon sa Kotlin

Ano ang typealias?

Typealias (alias ng uri) — isang deklarasyon na nagpapakilala ng alternatibong pangalan para sa isang umiiral na uri. Syntax: typealias BagongPangalan = UmiiralNaUri. Pagkatapos ng deklarasyon, ang BagongPangalan ay maaaring gamitin kahit saan kung saan inaasahan ang UmiiralNaUri — itinuturing sila ng compiler bilang parehong uri. Sa antas ng bytecode, ang typealias ay hindi nag-iiwan ng bakas: lahat ng impormasyon tungkol sa alias ay binubura sa yugto ng compilation.

Ang pangunahing layunin ng typealias ay pagpapabuti ng pagiging madaling mabasa ng code. Sa halip na isang mahabang lagda fun process(callback: (Result) -> Unit) maaaring sumulat ng typealias Callback = (Result) -> Unit at gamitin ang Callback bilang uri ng parameter. Ito ay lalong kapaki-pakinabang kapag ang parehong functional na uri ay umuulit sa maraming lugar sa code: ang alias ay nagsisilbing nag-iisang punto ng kahulugan at nagdodokumento ng layunin ng uri.

Ang typealias ay hindi lumilikha ng bagong uri — ito ay isang kasingkahulugan lamang. Ang mga variable ng uri Callback at (Result) -> Unit ay ganap na napagpapalit. Hindi magbibigay ng error ang compiler kung ang isang lambda ay direktang ipapasa sa isang function na umaasa ng Callback. Ito ang nagpapakilala sa typealias mula sa inline class (value class), na lumilikha ng bagong uri-ng-pambalot na may pagsusuri sa yugto ng compilation. Ang typealias ay pagpapalit ng pangalan, hindi pambalot.

Typealias para sa mga functional na uri

Ang pinakakaraniwang senaryo ng paggamit ng typealias sa Kotlin ay mga functional na uri. Ang mahahabang lagda tulad ng (Int, String) -> Boolean o (List) -> Result ay nagpapahirap sa pagbasa ng code. Ginagawang maikli at makabuluhang pangalan ng typealias ang mga ito na nagdodokumento ng layunin ng function: typealias Validator = (String) -> Boolean ay tumutukoy na ito ay isang validator ng string.

// Walang typealias
fun findUsers(
    filter: (List<User>) -> List<User>
): List<User>

// May typealias
typealias UserFilter = (List<User>) -> List<User>

fun findUsers(filter: UserFilter): List<User>

// Paggamit sa klase
typealias OnClickListener = (View) -> Unit

class Button {
    var onClick: OnClickListener = {}
}

Sa halimbawa, ang typealias UserFilter ay nagtatago ng kumplikadong functional na uri (List) -> List sa likod ng isang maikling pangalan. Ang lagda ng findUsers ay nagiging nababasa: «tumanggap ng UserFilter, nagbabalik ng List». Ang typealias OnClickListener ay ginagawang katulad ng deklarasyon ng interface ang code, ngunit walang overhead ng paglikha ng isang hiwalay na interface o abstract na klase. Ang mga lambda at anonymous na function ay patuloy na gumagana gaya ng dati — ang typealias ay hindi nangangailangan ng mga pagbabago sa tumatawag na code.

Typealias na may generics

Typealias ay sumusuporta sa mga generic na parameter, na ginagawang mas flexible. Maaaring tukuyin ang typealias Mapper = (T) -> R at gamitin sa anumang uri. Pinapalitan ng compiler ang mga konkreto na uri sa lugar ng mga parameter sa bawat paggamit ng alias, na pinapanatili ang buong kaligtasan ng uri.

// Generic na typealias
typealias Mapper<T, R> = (T) -> R
typealias Provider<T> = () -> T
typealias ListTransformer<T> = (List<T>) -> List<T>

fun processNumbers(mapper: Mapper<Int, String>) {
    // uri ng mapper ay (Int) -> String
}

fun main() {
    val config: Provider<String> = { "default config" }
    val reverse: ListTransformer<Int> = { it.reversed() }
}

Sa listing, Mapper — isang generic na alias para sa anumang pagbabago mula T patungong R. Provider — tagapagbigay ng halaga (pabrika na walang argumento). ListTransformer — function ng pagbabago ng listahan. Sa tawag na processNumbers(mapper: Mapper) binuksan ng compiler ang alias sa (Int) -> String. Ginagawa ng generics ang typealias na isang unibersal na kasangkapan na angkop para sa anumang konteksto nang walang pagdodoble ng mga deklarasyon.

Typealias para sa mga nested class at mahabang pangalan

Mga nested class at mahabang naka-parameter na uri — isa pang lugar kung saan ang typealias ay nagpapasimple ng code. Kung ang isang klase ay nasa malalim na bahagi ng hierarchy ng nesting (Outer.Inner.Nested), ang pagtukoy dito sa pamamagitan ng buong pangalan ay nagpapagulo sa code. Pinapaikli ng typealias ang pag-access na ito at ginagawa itong mas nababasa. Ito ay lalong mahalaga para sa mga klase mula sa mga third-party na library na may mahabang pangalan.

// Alias para sa nested class
class NetworkResponse {
    class Error(val code: Int, val message: String)
}
typealias NetworkError = NetworkResponse.Error

// Alias para sa mahabang uri ng library
typealias UserId = Long
typealias JsonMap = Map<String, Any?>

fun process(error: NetworkError) {
    println("${error.code}: ${error.message}")
}

fun parseJson(data: JsonMap): UserId {
    return data["id"] as? Long ?: 0L
}

Sa halimbawa, NetworkError — alias para sa nested class na NetworkResponse.Error. Sa pag-import ng typealias, ang NetworkError ay maaaring gamitin bilang isang ordinaryong uri, nang hindi isinisiwalat ang hierarchy ng nesting. JsonMap ay nagdodokumento na ang mapa ay kumakatawan sa isang JSON object. UserId ay nagpapaliwanag ng layunin ng Long sa partikular na konteksto — ang mambabasa ay agad na nauunawaan na ito ay isang identifier ng user, hindi isang arbitrary na numero. Gayunpaman, hindi pinoprotektahan ng typealias laban sa pagpasa ng ordinaryong Long kung saan inaasahan ang UserId — para diyan kailangan ang value class.

Typealias vs inline class: mga pagkakaiba

Typealias at inline class (value class) ay lumulutas ng iba't ibang gawain, kahit na pareho silang nagpapakilala ng bagong pangalan para sa isang uri. Ang typealias ay isang kasingkahulugan lamang: ang variable ng uri UserId = Long ay tumatanggap ng anumang Long nang walang pagsusuri. Ang inline class ay bumabalot ng halaga sa isang bagong uri na sinusuri sa yugto ng compilation: ang pagpasa ng ordinaryong Long kung saan inaasahan ang inline class UserId ay imposible nang walang tahasang conversion.

Ipinapakita ng talahanayan ang pagkakaiba sa pagitan ng dalawang mekanismo. Typealias ay angkop para sa maiikling pangalan at dokumentasyon ng code kapag hindi kinakailangan ang mahigpit na pag-type. Ang inline class sa pamamagitan ng keyword na value class (dating inline class) ay kinakailangan kapag mahalagang pag-ibahin ang mga semantikong magkaibang halaga ng parehong primitive na uri. Halimbawa, ang UserId at OrderId ay parehong Long, ngunit ang pagpasa ng isa kung saan inaasahan ang isa ay isang lohikal na error na pinipigilan ng value class sa yugto ng compilation.