Typealias — यह क्या है, सिंटैक्स और Kotlin में उपयोग

Typealias क्या है?

Typealias (प्रकार उपनाम) एक घोषणा है जो मौजूदा प्रकार के लिए एक वैकल्पिक नाम प्रस्तुत करती है। सिंटैक्स: typealias नयानाम = मौजूदाप्रकार। घोषणा के बाद, नयानाम का उपयोग वहाँ किया जा सकता है जहाँ मौजूदाप्रकार अपेक्षित है — संकलक उन्हें एक ही प्रकार मानता है। बाइटकोड स्तर पर, typealias कोई निशान नहीं छोड़ता: सभी उपनाम जानकारी संकलन समय पर मिटा दी जाती है।

Typealias का मुख्य उद्देश्य कोड पठनीयता में सुधार करना है। एक लंबे हस्ताक्षर fun process(callback: (Result) -> Unit) के बजाय, आप typealias Callback = (Result) -> Unit लिख सकते हैं और Callback को पैरामीटर प्रकार के रूप में उपयोग कर सकते हैं। यह विशेष रूप से उपयोगी है जब एक ही फ़ंक्शनल प्रकार कोड में कई स्थानों पर दोहराया जाता है: उपनाम परिभाषा के एकल बिंदु के रूप में कार्य करता है और प्रकार के उद्देश्य का दस्तावेज़ीकरण करता है।

Typealias एक नया प्रकार नहीं बनाता — यह सिर्फ एक पर्याय है। Callback और (Result) -> Unit प्रकार के चर पूरी तरह से विनिमेय हैं। यदि Callback की अपेक्षा करने वाले फ़ंक्शन में सीधे लैम्ब्डा पास किया जाता है तो संकलक त्रुटि नहीं देगा। यह typealias को inline class (value class) से अलग करता है, जो संकलन-समय जाँच के साथ एक नया रैपर प्रकार बनाता है। Typealias पुनर्नामकरण है, आवरण नहीं।

फ़ंक्शनल प्रकारों के लिए Typealias

Kotlin में typealias का सबसे सामान्य उपयोग फ़ंक्शनल प्रकारों के लिए है। (Int, String) -> Boolean या (List) -> Result जैसे लंबे हस्ताक्षर कोड को पढ़ने में कठिन बनाते हैं। Typealias उन्हें छोटे सार्थक नामों में बदल देता है जो फ़ंक्शन के उद्देश्य का दस्तावेज़ीकरण करते हैं: typealias Validator = (String) -> Boolean निर्दिष्ट करता है कि यह एक स्ट्रिंग सत्यापनकर्ता है।

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

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

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

// Usage in class
typealias OnClickListener = (View) -> Unit

class Button {
    var onClick: OnClickListener = {}
}

उदाहरण में, typealias UserFilter जटिल फ़ंक्शनल प्रकार (List) -> List को एक छोटे नाम के पीछे छिपाता है। findUsers का हस्ताक्षर पठनीय हो जाता है: "UserFilter स्वीकार करता है, List लौटाता है"। typealias OnClickListener कोड को एक इंटरफ़ेस घोषणा जैसा बनाता है लेकिन एक अलग इंटरफ़ेस या अमूर्त वर्ग बनाने के ओवरहेड के बिना। इस बीच, लैम्ब्डा और अनाम फ़ंक्शन हमेशा की तरह काम करते रहते हैं — typealias को कॉल करने वाले कोड में बदलाव की आवश्यकता नहीं होती।

जेनेरिक्स के साथ Typealias

Typealias सामान्य पैरामीटर (जेनेरिक्स) सपोर्ट करता है, जो इसे और भी लचीला बनाता है। आप typealias Mapper = (T) -> R परिभाषित कर सकते हैं और इसे किसी भी प्रकार के साथ उपयोग कर सकते हैं। संकलक उपनाम के प्रत्येक उपयोग पर पैरामीटर के स्थान पर विशिष्ट प्रकार रखता है, पूर्ण प्रकार सुरक्षा बनाए रखता है।

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

fun processNumbers(mapper: Mapper<Int, String>) {
    // mapper type is (Int) -> String
}

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

सूची में, Mapper T से R में किसी भी रूपांतरण के लिए एक सामान्य उपनाम है। Provider एक मान आपूर्तिकर्ता है (बिना तर्कों का कारखाना)। ListTransformer एक सूची रूपांतरण फ़ंक्शन है। processNumbers(mapper: Mapper) कॉल करते समय, संकलक उपनाम को (Int) -> String में विस्तारित करता है। जेनेरिक्स typealias को एक सार्वभौमिक उपकरण बनाते हैं जो घोषणाओं की नकल किए बिना किसी भी संदर्भ के लिए उपयुक्त है।

नेस्टेड और लंबे नामों के लिए Typealias

नेस्टेड क्लासेस और लंबे पैरामीटरीकृत प्रकार एक और क्षेत्र हैं जहाँ typealias कोड को काफी सरल बनाता है। यदि कोई क्लास नेस्टिंग पदानुक्रम (Outer.Inner.Nested) में गहरी है, तो पूरे नाम से संदर्भ कोड को अव्यवस्थित करता है। Typealias ऐसी पहुँच को छोटा करता है और इसे अधिक पठनीय बनाता है। यह विशेष रूप से लंबे नामों वाली तृतीय-पक्ष लाइब्रेरी की क्लासेस के लिए प्रासंगिक है।

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

// Alias for long library type
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
}

उदाहरण में, NetworkError नेस्टेड क्लास NetworkResponse.Error के लिए एक उपनाम है। typealias आयात करके, आप NetworkError को नेस्टिंग पदानुक्रम को प्रकट किए बिना एक सामान्य प्रकार के रूप में उपयोग कर सकते हैं। JsonMap दस्तावेज़ित करता है कि मानचित्र एक JSON ऑब्जेक्ट का प्रतिनिधित्व करता है। UserId एक विशिष्ट संदर्भ में Long के उद्देश्य को स्पष्ट करता है — पाठक तुरंत समझ जाता है कि यह एक उपयोगकर्ता पहचानकर्ता है, न कि कोई मनमाना नंबर। हालाँकि, typealias जहाँ UserId अपेक्षित है वहाँ सादा Long पास करने से नहीं रोकता — इसके लिए value class की आवश्यकता है।

Typealias बनाम Inline Class: अंतर

Typealias और inline class (value class) अलग-अलग समस्याओं का समाधान करते हैं, हालाँकि दोनों एक प्रकार के लिए एक नया नाम प्रस्तुत करते हैं। Typealias सिर्फ एक पर्याय है: UserId = Long प्रकार का एक चर बिना जाँच के किसी भी Long को स्वीकार करता है। Inline class एक मान को एक नए प्रकार में लपेटता है जिसे संकलन समय पर जाँचा जाता है: जहाँ inline class UserId अपेक्षित है वहाँ सादा Long पास करना स्पष्ट रूपांतरण के बिना असंभव है।

तालिका दो क्रियाविधियों के बीच अंतर दिखाती है। Typealias संक्षिप्त नामों और कोड दस्तावेज़ीकरण के लिए उपयुक्त है जब सख्त टाइपिंग की आवश्यकता नहीं होती। value class कीवर्ड (पूर्व में inline class) के माध्यम से Inline class की आवश्यकता तब होती है जब एक ही आदिम प्रकार के शब्दार्थ रूप से भिन्न मानों के बीच अंतर करना महत्वपूर्ण हो। उदाहरण के लिए, UserId और OrderId दोनों Long हैं, लेकिन जहाँ दूसरे की अपेक्षा है वहाँ एक को पास करना एक तार्किक त्रुटि है जिसे value class संकलन समय पर रोकता है।