Come limitare i sottotipi in un array in Swift?

In Swift, non è possibile limitare direttamente i sottotipi negli array con tipi di elementi omogenei. Tuttavia, è possibile ottenere un comportamento simile utilizzando i seguenti approcci:

1. Utilizzo di protocolli: Definire un protocollo generale per tutti i sottotipi consentiti e usarlo come tipo degli elementi dell'array.

   protocol SpecificType {}
   
   class SubtypeA: SpecificType {}
   class SubtypeB: SpecificType {}
   class AnotherType {}
   
   var specificArray: [SpecificType] = [] // Array contenente solo tipi che implementano SpecificType
   
   specificArray.append(SubtypeA())
   specificArray.append(SubtypeB())
   // specificArray.append(AnotherType()) // Errore di compilazione, AnotherType non rispetta il protocollo
   

2. Utilizzo di generici con restrizione tramite protocollo: Se si crea una collezione o funzione personalizzata, si possono usare generici con restrizione tramite protocollo.

   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 solo di SubtypeA che rispettano SpecificType
   // var invalidArray = RestrictedArray<AnotherType>() // Errore di compilazione, AnotherType non rispetta il protocollo
   

3. Utilizzo di enumerazioni (Enum) con valori associati: Se il numero di sottotipi è fisso e noto in anticipo, si può usare un’enumerazione.

   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())) // Errore di tipo all’interno del valore associato
   

Pertanto, la restrizione diretta dei sottotipi in un array [SomeType] standard non è possibile. Al suo posto, si utilizzano protocolli, generici con restrizioni o enumerazioni per garantire la sicurezza statica dei tipi.