როდის ხდება ინლაინ-ფუნქციების გამოყენებისას გადატვირთვა?

Kotlin-ში inline ფუნქციების გადატვირთვა (inline functions) ჩვეულებრივ დროის პოლიმორფიზმის მნიშვნელობაში არ ხდება. Inline ფუნქცია ინტროდდება გამოძახების ადგილას კომპილაციის დროს. ამიტომ, როდესაც ვსაუბრობთ "გადატვირთვაზე" inline ფუნქციებთან დაკავშირებით, ჩვენ ხშირად ვგულისხმობთ კომპილატორის შესაძლებლობას, შექმნას რამდენიმე ვერსია ინტროდირებული კოდის სხვადასხვა კონტექსტებისთვის, განსაკუთრებით გენერიკების გამოყენებისას.

ძირითადი მახასიათებლები:

• კომპილაციის დროს სპეციალიზაცია: reified გენერიკების მქონე inline-ფუნქციებისთვის, კომპილატორი ქმნის სპეციალიზებულ ვერსიებს თითოეულ კონკრეტულ ტიპზე, რომელიც შეცვლილია ტიპური პარამეტრის ნაცვლად. ეს ხდება კომპილაციის დროს, არა შესრულების დროს.
• დამატებითი ხარჯების თავიდან აცილება: Inline-ის მიზანია ფუნქციის გამოძახების ხარჯების გამორიცხვა. გენერიკების სპეციალიზაცია საშუალებას აძლევს თავიდან აიცილოს პრიმიტიული ტიპების შეფუთვა და სხვა ხარჯები, რომლებიც დაკავშირებულია Java-ში ტიპის დაკარგვასთან.
• პოლიმორფიზმი არაა: ეს არ არის კლასიკური პოლიმორფიზმი, სადაც გადაფარებული მეთოდი გამოიძახება ობიექტის რეალურ ტიპზე დაყრდნობით შესრულების დროს. აქ "ვერსიის" არჩევა ხდება კომპილაციის დროს.

reified-თან ერთად inline-ფუნქციის გამოყენების მაგალითი:

inline fun <reified T> printType(value: T) {
    // კომპილატორი შექმნის სხვადასხვა კოდს თითოეულ T-ისთვის (Int, String და სხვა)
    println("Type is: ${T::class.java.name}")
}

fun main() {
    printType(123) // კოდი გენერირდება T = Int-ისთვის
    printType("Hello") // კოდი გენერირდება T = String-ისთვის
}

ამ შემთხვევაში, სინტაქსურად ჩვენ ვიძახით ერთ ფუნქციას printType, მაგრამ კომპილატორი ქმნის ორ განსხვავებულ ვერსიას: ერთს Int-ისთვის და ერთს String-ისთვის. ეს შეიძლება განვიხილოთ როგორც "გადატვირთვა" ან უფრო ზუსტად, კომპილაციის დროის სპეციალიზაცია, რომელიც ხდება ინლაინის მექანიზმის წყალობით, არა შესრულების დროის პოლიმორფიზმის.