¿Cómo limitar los subtipos en un array en Swift?

En Swift, no se puede restringir directamente los subtipos en arreglos con tipos homogéneos de elementos. Sin embargo, se puede lograr un comportamiento similar utilizando los siguientes enfoques:

1. Uso de protocolos: Definir un protocolo general para todos los subtipos permitidos y usarlo como tipo de los elementos del arreglo.

   protocol SpecificType {}
   
   class SubtypeA: SpecificType {}
   class SubtypeB: SpecificType {}
   class AnotherType {}
   
   var specificArray: [SpecificType] = [] // Arreglo que contiene solo tipos que cumplen con SpecificType
   
   specificArray.append(SubtypeA())
   specificArray.append(SubtypeB())
   // specificArray.append(AnotherType()) // Error de compilación, AnotherType no cumple con el protocolo
   

2. Uso de genéricos con restricción por protocolo: Si creas una colección o función propia, puedes usar genéricos con restricción por protocolo.

   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>() // Arreglo solo de SubtypeA que cumplen con SpecificType
   // var invalidArray = RestrictedArray<AnotherType>() // Error de compilación, AnotherType no cumple con el protocolo
   

3. Uso de enumeraciones (Enum) con valores asociados: Si el número de subtipos es fijo y conocido de antemano, se puede usar una enumeración.

   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())) // Error de tipo dentro del valor asociado
   

Por lo tanto, la restricción directa de subtipos en un array estándar [SomeType] no es posible. En su lugar, se utilizan protocolos, genéricos con restricciones o enumeraciones para garantizar la seguridad de tipos en tiempo de compilación.