Generic — η ουσία των γενικών τύπων και η παράμετρος T

Τι είναι το Generic στο Swift;

Generic (γενικός τύπος) — είναι μια συντακτική κατασκευή Swift που επιτρέπει τη σύνταξη ευέλικτου, επαναχρησιμοποιήσιμου κώδικα με παραμετροποίηση τύπου. Αντί για συγκεκριμένο τύπο, γράφεται ένα placeholder σε γωνιακές αγκύλες — συνήθως , αλλά μπορεί να χρησιμοποιηθεί οποιοδήποτε όνομα. Το Generic βρίσκεται στη βάση του SwiftUI (View, some View), της τυπικής βιβλιοθήκης (Array, Optional) και του Combine.

Γιατί χρειάζονται τα Generic

Χωρίς generic θα έπρεπε να γράφονται ξεχωριστές συναρτήσεις για κάθε τύπο: swapInts, swapStrings, swapDates. Η generic συνάρτηση swap αντικαθιστά και τις τρεις παραλλαγές με μία δήλωση. Αυτό μειώνει την αντιγραφή, αυξάνει την αναγνωσιμότητα και μειώνει την πιθανότητα σφαλμάτων κατά την αντιγραφή κώδικα.

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 10
var y = 20
swapValues(&x, &y)

Ο μεταγλωττιστής Swift παράγει εξειδικευμένο κώδικα για κάθε συγκεκριμένη χρήση generic. Αυτό σημαίνει ότι η generic συνάρτηση swapValues δεν έχει επιβάρυνση σε σύγκριση με μια χειρόγραφη συνάρτηση για Int. Το Swift δεν χρησιμοποιεί διαγραφή τύπων όπως η Java — το generic υπάρχει τόσο στη φάση μεταγλώττισης όσο και κατά τον χρόνο εκτέλεσης (αν και η βελτιστοποίηση μπορεί να τα εξειδικεύσει).

Γενικές συναρτήσεις με παράμετρο T

Generic συναρτήσεις — είναι συναρτήσεις που δέχονται μία ή περισσότερες παραμέτρους-τύπους. Οι παράμετροι-τύποι υποδεικνύονται μετά το όνομα της συνάρτησης σε γωνιακές αγκύλες: . Μπορούν να χρησιμοποιηθούν στην υπογραφή: τύπος ορίσματος, τύπος επιστροφής και εντός του σώματος της συνάρτησης.

Πολλαπλές παράμετροι-τύποι

Μια συνάρτηση μπορεί να έχει πολλαπλές παραμέτρους generic. Για παράδειγμα, η συνάρτηση findKey δέχεται ένα λεξικό με κλειδιά K και τιμές V. Κάθε παράμετρος-τύπος είναι μοναδική και μπορεί να χρησιμοποιηθεί σε περιορισμούς.

func findKey<K: Hashable, V>(
    for value: V,
    in dictionary: [K: V]
) -> K? where V: Equatable {
    for (key, dictValue) in dictionary {
        if dictValue == value {
            return key
        }
    }
    return nil
}

Οι περιορισμοί K: Hashable και where V: Equatable εγγυώνται ότι η findKey μπορεί να κληθεί μόνο με λεξικό του οποίου τα κλειδιά είναι κατακερματίσιμα και οι τιμές συγκρίσιμες. Τέτοιοι περιορισμοί δεν είναι γραφειοκρατία, αλλά αναγκαιότητα: χωρίς Hashable δεν μπορεί να γίνει ευρετηρίαση αναζήτησης βάσει κλειδιού, χωρίς Equatable δεν μπορεί να συγκριθεί το value με το dictValue.

Περιορισμοί τύπου μέσω where

where — είναι μια λέξη-κλειδί Swift που επιβάλλει πρόσθετους περιορισμούς στις παραμέτρους generic. Σε αντίθεση με την απλή υπόδειξη πρωτοκόλλου σε γωνιακές αγκύλες (), το where επιτρέπει την έκφραση πιο σύνθετων συνθηκών: συμμόρφωση με πολλαπλά πρωτόκολλα, σχέση μεταξύ παραμέτρων-τύπων και εξειδίκευση associated types.

Σύνταξη where

Η πρόταση where γράφεται μετά την υπογραφή της συνάρτησης ή του τύπου, πριν από το άνοιγμα του αγκίστρου. Στο where μπορεί να καθοριστεί ότι T: Comparable & Hashable (ταυτόχρονα δύο πρωτόκολλα), ή ότι T.U == Int (εξειδίκευση associated type).

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

extension Container where Item: Comparable {
    func isSorted() -> Bool {
        // Implementation available only if Item: Comparable
        return true
    }
}

Η επέκταση με where προσθέτει μεθόδους μόνο για εκείνους τους τύπους που ικανοποιούν την συνθήκη. Το Container λαμβάνει τη μέθοδο isSorted, ενώ το Container όχι, επειδή το Any δεν είναι Comparable. Αυτός είναι ένας ισχυρός μηχανισμός υπό συνθήκη λειτουργικότητας.

Associated Types σε πρωτόκολλα

Associated Types (συσχετιζόμενοι τύποι) — είναι ένας τρόπος να γίνει το πρωτόκολλο γενικό χωρίς να καθορίζεται ο συγκεκριμένος τύπος στη φάση δήλωσης. Αντί για , το πρωτόκολλο δηλώνει ένα associatedtype, το οποίο εξειδικεύεται στην υλοποίηση. Αυτό είναι ιδιαίτερα σημαντικό για συλλογές: το πρωτόκολλο Sequence δεν γνωρίζει ποια στοιχεία θα περιέχει η ακολουθία.

Σύνδεση associated types μέσω where

Με τη βοήθεια του where μπορούν να δημιουργηθούν συνδέσεις μεταξύ associated types διαφορετικών πρωτοκόλλων. Για παράδειγμα, μπορεί να απαιτηθεί το Item ενός πρωτοκόλλου να ταιριάζει με το Iterator.Element ενός άλλου. Αυτό εγγυάται συμβατότητα τύπων σε επίπεδο μεταγλώττισης.

protocol StackProtocol {
    associatedtype Element
    mutating func push(_ item: Element)
    mutating func pop() -> Element?
}

struct IntStack: StackProtocol {
    typealias Element = Int
    private var items: [Int] = []
    
    mutating func push(_ item: Int) { items.append(item) }
    mutating func pop() -> Int? { items.popLast() }
}

Το IntStack εξειδικεύει το Element ως Int, χρησιμοποιώντας typealias. Ο μεταγλωττιστής ελέγχει αν όλες οι απαιτήσεις του πρωτοκόλλου εκπληρώνονται με αυτόν τον τύπο. Χωρίς associated types θα έπρεπε να γραφτεί StackProtocol με generic πρωτόκολλο, αλλά το Swift χρησιμοποιεί associated types για ομοιομορφία με τις γέφυρες Objective-C και καλύτερη αναγνωσιμότητα.

Generic σε επεκτάσεις και subscript

Generic επεκτάσεις επιτρέπουν την προσθήκη μεθόδων σε έναν generic τύπο με πρόσθετους περιορισμούς. Αυτό είναι το μοτίβο “υπό όρους συμμόρφωσης”, όταν ο τύπος αποκτά λειτουργικότητα μόνο υπό ορισμένες συνθήκες. Τα subscript μπορούν επίσης να είναι generic.

Generic subscript

Ένα subscript μπορεί να είναι γενικό: δέχεται παραμέτρους generic σε γωνιακές αγκύλες. Αυτό είναι χρήσιμο για ασφαλή πρόσβαση σε συλλογές με αυθαίρετο δείκτη, όταν ο δείκτης μπορεί να είναι διαφορετικών τύπων.

extension Array where Element: Numeric {
    func sum() -> Element {
        return reduce(0, +)
    }
}

extension Array {
    subscript<Indices: Sequence>(indices: Indices) -> [Element]
        where Indices.Element == Int {
        return indices.map { self[$0] }
    }
}

Μια τέτοια κατασκευή παρέχει ισχυρή σύνθεση: η μέθοδος sum εμφανίζεται μόνο σε αριθμητικούς πίνακες, και το subscript με αυθαίρετους δείκτες λειτουργεί με οποιαδήποτε ακολουθία ακέραιων δεικτών. Ο μεταγλωττιστής διαχειρίζεται την ορατότητα αυτών των μελών βάσει των συνθηκών where.

Τυπικά λάθη κατά την εργασία με generics

Λάθη κατά τη χρήση generic συχνά σχετίζονται με εσφαλμένους περιορισμούς ή προσπάθεια χρήσης generic εκεί όπου χρειάζεται συγκεκριμένος τύπος. Ας εξετάσουμε τρία συνηθισμένα σενάρια που αντιμετωπίζουν οι προγραμματιστές.

Υπερβολική παραμετροποίηση

Η προσθήκη παραμέτρων generic εκεί όπου επαρκεί ένας συγκεκριμένος τύπος — είναι αντ-πρότυπο. Αν μια συνάρτηση λειτουργεί πάντα με String, δεν χρειάζεται να γίνει . Αυτό περιπλέκει τον κώδικα χωρίς όφελος. Το Generic δικαιολογείται όταν ο τύπος πραγματικά μεταβάλλεται, όχι για αφηρημένη “μελλοντική ευελιξία”.

Απουσία περιορισμού where

Η κλήση μεθόδου σε παράμετρο generic χωρίς να καθορίζεται ότι η μέθοδος υπάρχει — είναι λάθος. δεν μπορεί να καλέσει .count αν δεν έχει καθοριστεί ότι T: Collection. Πάντα να προσθέτετε περιορισμούς στις παραμέτρους-τύπους, διαφορετικά ο μεταγλωττιστής θα απορρίψει τον κώδικα.

// ❌ Error: value has no count method
func countElements<T>(value: T) -> Int { value.count }

// ✅ Works: T: Collection guarantees count exists
func countElements<T: Collection>(value: T) -> Int { value.count }

Το λάθος είναι κατανοητό: το generic μπορεί να είναι οποιοσδήποτε τύπος και ο μεταγλωττιστής δεν γνωρίζει αν έχει count. Ο περιορισμός Collection λύνει το πρόβλημα. Παρόμοια για Equatable, Hashable, Numeric — πάντα να καθορίζετε το πρωτόκολλο αν σκοπεύετε να καλέσετε μεθόδους ή τελεστές στην παράμετρο generic.