Como limitar os subtipos numa matriz em Swift?

Em Swift, não é possível restringir diretamente os subtipos em arrays com tipos homogêneos de elementos. No entanto, pode-se alcançar um comportamento semelhante usando as seguintes abordagens:

1. Utilização de protocolos: Definir um protocolo geral para todos os subtipos permitidos e usá-lo como tipo dos elementos do array.

   protocol SpecificType {}
   
   class SubtypeA: SpecificType {}
   class SubtypeB: SpecificType {}
   class AnotherType {}
   
   var specificArray: [SpecificType] = [] // Array contendo apenas tipos que implementam SpecificType
   
   specificArray.append(SubtypeA())
   specificArray.append(SubtypeB())
   // specificArray.append(AnotherType()) // Erro de compilação, AnotherType não corresponde ao protocolo
   

2. Utilização de genéricos com restrição por protocolo: Se criar uma coleção ou função própria, pode usar genéricos com restrição 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>() // Array apenas de SubtypeA que implementam SpecificType
   // var invalidArray = RestrictedArray<AnotherType>() // Erro de compilação, AnotherType não corresponde ao protocolo
   

3. Utilização de enumeração (Enum) com valores associados: Se o número de subtipos for fixo e conhecido de antemão, pode usar uma enumeração.

   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())) // Erro de tipo dentro do valor associado
   

Assim, a restrição direta de subtipos em um array padrão [SomeType] não é possível. Em vez disso, usam-se protocolos, genéricos com restrições ou enumerações para garantir a segurança de tipos estática.