Hoe beperk je subtypes in een array in Swift?

In Swift is het niet mogelijk om subtypes rechtstreeks te beperken in arrays met homogeen type elementen. Echter, je kunt vergelijkbaar gedrag bereiken door gebruik te maken van de volgende benaderingen:

1. Gebruik van protocollen: Definieer een algemeen protocol voor alle toegestane subtypes en gebruik dit als het type van de array-elementen.

   protocol SpecificType {}
   
   class SubtypeA: SpecificType {}
   class SubtypeB: SpecificType {}
   class AnotherType {}
   
   var specificArray: [SpecificType] = [] // Array met alleen types die SpecificType implementeren
   
   specificArray.append(SubtypeA())
   specificArray.append(SubtypeB())
   // specificArray.append(AnotherType()) // Compileerfout, AnotherType voldoet niet aan het protocol
   

2. Gebruik van generics met restrictie via protocol: Als je een eigen collectie of functie maakt, kun je generics gebruiken met restrictie via protocol.

   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>() // Array alleen van SubtypeA die SpecificType implementeren
   // var invalidArray = RestrictedArray<AnotherType>() // Compileerfout, AnotherType voldoet niet aan het protocol
   

3. Gebruik van enumeraties (Enum) met geassocieerde waarden: Als het aantal subtypes vast en vooraf bekend is, kun je een enumeratie gebruiken.

   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())) // Typefout binnen de geassocieerde waarde
   

Dus, het direct beperken van subtypes in een standaard [SomeType] array is niet mogelijk. In plaats daarvan worden protocollen, generics met restricties of enumeraties gebruikt om statische typeveiligheid te garanderen.