Jak ograniczyć podtypy w tablicy w Swift?

W Swift nie można bezpośrednio ograniczyć podtypów w tablicach z jednorodnym typem elementów. Jednak można osiągnąć podobne zachowanie, korzystając z następujących podejść:

1. Użycie protokołów: Zdefiniuj ogólny protokół dla wszystkich dozwolonych podtypów i użyj go jako typu elementów tablicy.

   protocol SpecificType {}
   
   class SubtypeA: SpecificType {}
   class SubtypeB: SpecificType {}
   class AnotherType {}
   
   var specificArray: [SpecificType] = [] // Tablica zawierająca tylko typy implementujące SpecificType
   
   specificArray.append(SubtypeA())
   specificArray.append(SubtypeB())
   // specificArray.append(AnotherType()) // Błąd kompilacji, AnotherType nie spełnia protokołu
   

2. Użycie generyków z ograniczeniem przez protokół: Jeśli tworzysz własną kolekcję lub funkcję, możesz użyć generyków z ograniczeniem przez protokół.

   struct RestrictedArray<T: SpecificType> {
       private var elements: [T] = []
   
       mutating func append(_ element: T) {
           elements.append(element)
       }
   
       func getElements() -> [T] {
           return elements
       }
   }
   
   // var validArray = RestrictedArray<SubtypeA>() // Tablica tylko SubtypeA spełniających SpecificType
   // var invalidArray = RestrictedArray<AnotherType>() // Błąd kompilacji, AnotherType nie spełnia protokołu
   

3. Użycie wyliczeń (Enum) z wartościami skojarzonymi: Jeśli liczba podtypów jest stała i znana z góry, można użyć wyliczenia.

   enum AllowedSubtypes {
       case typeA(SubtypeA)
       case typeB(SubtypeB)
   }
   
   class SubtypeA {}
   class SubtypeB {}
   
   var enumArray: [AllowedSubtypes] = []
   
   enumArray.append(.typeA(SubtypeA()))
   enumArray.append(.typeB(SubtypeB()))
   // enumArray.append(.typeA(SubtypeB())) // Błąd typu wewnątrz wartości skojarzonej
   

W związku z tym, bezpośrednie ograniczenie podtypów w standardowej tablicy [SomeType] nie jest możliwe. Zamiast tego używa się protokołów, generyków z ograniczeniami lub wyliczeń, aby zapewnić statyczne bezpieczeństwo typów.