Typealias: ano ito, syntax at paggamit

Ano ang Typealias?

Typealias — ay isang deklarasyon sa Swift na nagpapakilala ng alternatibong pangalan para sa isang umiiral na uri. Pagkatapos ideklara ang typealias, ang bagong pangalan ay maaaring gamitin kahit saan inaasahan ang orihinal na uri — tinatrato sila ng compiler bilang magkapareho. Ang typealias ay hindi nagdaragdag ng semantic isolation: ang halaga ng uri UserID (typealias para sa String) ay maaaring ipasa sa isang function na umaasa ng String nang walang error.

Ang mga pangunahing layunin ng typealias — pagpapaikli ng mahabang pangalan, pagdodokumento ng layunin ng uri at pag-abstrak ng konkretong implementasyon. Halimbawa, typealias JSON = [String: Any] ay malinaw na nagpapahiwatig na ang diksyunaryo ay ginagamit bilang JSON structure, at typealias Completion = (Result<Data, Error>) -> Void ay ginagawang nababasang uri ang isang kumplikadong lagda ng closure.

Ayon sa Swift.org (2025), ang typealias ay malawakang ginagamit sa standard library. Halimbawa, String — ay typealias para sa String (isang espesyalisadong Array<Character>), kahit na sa modernong bersyon ng Swift ang implementasyong ito ay nakatago. Void — typealias para sa walang laman na tuple (), na ginagawang mas nababasa ang mga lagda ng function.

Gamitin ang typealias para idokumento ang semantics ng uri, ngunit tandaan: hindi ito nagpoprotekta laban sa paghahalo ng iba't ibang konsepto ng parehong base na uri. Para sa ligtas na paghihiwalay ng uri, gumamit ng mga pambalot (struct wrapper).

Syntax at mga saklaw ng visibility

Ang typealias ay idineklara gamit ang keyword na typealias, na sinusundan ng bagong pangalan, equal sign at ang umiiral na uri. Pangunahing anyo:

typealias Name = ExistingType
typealias UserID = Int
typealias JSONDictionary = [String: Any]

Ang saklaw ng visibility ng typealias ay tinutukoy ng lugar ng deklarasyon:

Ang typealias sa loob ng uri (halimbawa User.ID) — isang karaniwang pattern para sa pag-grupo ng mga kaugnay na alias. Pinapabuti nito ang namespace: Order.ID at User.ID — parehong Int, ngunit binabasa bilang magkaibang konsepto. Ang pag-access sa nested typealias ay sa pamamagitan ng User.ID o sa pamamagitan ng tuldok kung kilala ang uri.

Typealias para sa mga uri ng closure

Isa sa mga pinakakaraniwang gamit ng typealias — pagpapasimple ng mga lagda ng closure. Ang mga uri ng closure sa Swift ay maaaring maging masalimuot, lalo na sa Optional at generic na parameter. Ginagawang nababasang FetchResultHandler ng typealias ang (Data?, Error?) -> Void:

typealias FetchResultHandler = (Data?, Error?) -> Void

func fetchUser(id: Int, completion: FetchResultHandler) {
    // kahilingan sa network
    completion(data, nil)
}

Ayon sa Ray Wenderlich Style Guide, ang typealias para sa closure ay nagpapataas ng pagiging madaling mabasa ng mga lagda ng method, lalo na sa mga protocol ng delegasyon at mga pattern ng callback. Gayunpaman, iwasan ang labis na bilang ng mga alias — kung ang closure ay ginagamit sa isang lugar, maaari itong ideklara nang inline.

Aktibong ginagamit ng Swift standard library ang pamamaraang ito. Halimbawa, DispatchQueue.WorkItem — ay typealias para sa DispatchWorkItem, kahit na sa panlabas ay mukhang isang hiwalay na uri. Ang typealias para sa closure ay isang tool para sa pagiging madaling mabasa, huwag abusuhin ito: 3–5 alias ng closure bawat module — isang makatwirang limitasyon.

Typealias at generic na parameter

Ang typealias ay maaaring magsama ng generic na parameter, na lumilikha ng mga espesyalisadong bersyon ng mga generalisadong uri. Ito ay lalong kapaki-pakinabang kapag nagtatrabaho sa Result, Publisher at iba pang generic na uri mula sa standard library at Combine:

typealias FetchResult = Result<Data, Error>
typealias AnyPublisherOfData = AnyPublisher<Data, Error>

func loadData() -> FetchResult {
    // pagkarga ng data
}

Maaari ring lumikha ng typealias na may sariling generic na parameter na idinidirekta sa orihinal na uri:

typealias NetworkResult<T> = Result<T, NetworkError>

func fetchUser() -> NetworkResult<User> {
    // ...
}

Isang mahalagang patakaran: ang typealias ay hindi maaaring magdagdag ng bagong generic na paghihigpit (where clauses) — ito ay nagdidirekta lamang ng mga parameter sa orihinal na uri. Kung kailangan ang karagdagang paghihigpit, gumawa ng generic na istraktura o klase. Ayon sa Swift by Sundell (2024), ang typealias na may generic — perpektong paraan upang paikliin ang paulit-ulit na lagda sa mga proyektong aktibong gumagamit ng Combine, Result at async/await.

Associatedtype sa mga protocol

Associatedtype — ay typealias na idineklara sa loob ng protocol, na tumutukoy ng kaugnay na uri. Hindi tulad ng karaniwang typealias, ang associatedtype ay hindi nakatali sa isang tiyak na uri sa yugto ng deklarasyon — ito ay ikinokonkreto ng bawat uri na kumukumpirma sa protocol:

protocol Container {
    associatedtype Item
    var count: Int { get }
    mutating func append(_ item: Item)
}

struct IntBox: Container {
    typealias Item = Int
    // implementasyon
}

struct StringBox: Container {
    typealias Item = String
    // implementasyon
}

Ang associatedtype ay nagbibigay sa mga protocol ng flexibility ng generic na uri nang hindi tinutukoy ang konkretong uri sa lugar ng deklarasyon. Ito ang pundasyon ng maraming pattern ng Swift: Collection (Element), IteratorProtocol (Element), Identifiable (ID). Maaaring awtomatikong mahinuha ng compiler ang associatedtype mula sa implementasyon, kaya naman ang tahasang typealias Item = Int ay madalas na inaalis — hinuhusgahan ng Swift ang Item bilang Int mula sa parameter ng method na append.

Ayon sa Swift Evolution SE-0195 (2022), ipinakilala ang opaque result types (some Container) para sa pagtatrabaho sa mga protocol na naglalaman ng associatedtype — nalutas nito ang problema ng PAT (protocol with associated types), na hindi magamit bilang uri ng variable.

Typealias vs pambalot ng uri

Ang pangunahing pagkakaiba: typealias — ay ibang pangalan lamang para sa isang umiiral na uri, at ang pambalot (wrapper) — isang bagong uri, semantically isolated mula sa orihinal. Kung ideklara mo ang typealias UserID = Int, ang UserID at Int ay mapagpapalit — ang isang function na umaasa ng Int ay tatanggap ng UserID nang walang error.

Ang pambalot ay nilikha sa pamamagitan ng struct at nagbibigay ng tunay na kaligtasan ng uri:

struct UserID: RawRepresentable {
    let rawValue: Int
}

struct OrderID: RawRepresentable {
    let rawValue: Int
}

// Error sa compilation: hindi maipasa ang OrderID kung saan inaasahan ang UserID

Ayon sa Point-Free (2025), ang mga pambalot ay mas gusto kapag ang magkaibang konsepto ay kinakatawan ng isang base na uri (UserID vs OrderID). Ang typealias ay makatwiran kapag ang layunin ay pagiging madaling mabasa nang walang isolation: pagpapaikli ng mahabang pangalan, pagdodokumento ng semantics, pag-abstrak ng implementasyon sa pamamagitan ng associatedtype. Piliin ang typealias para sa kaginhawaan ng pagbasa, pambalot — para sa kaligtasan ng uri.