How to restrict subtypes in an array in Swift?

In Swift, you cannot directly restrict subtypes for arrays with homogeneous element types. However, you can achieve similar behavior using the following approaches:

Using a Protocol: Define a common protocol for all allowed subtypes and use it as the element type of the array.

protocol SpecificType {}

class SubtypeA: SpecificType {}
class SubtypeB: SpecificType {}
class AnotherType {}

var specificArray: [SpecificType] = [] // Array containing only types that conform to SpecificType

specificArray.append(SubtypeA())
specificArray.append(SubtypeB())
// specificArray.append(AnotherType()) // Compilation error, AnotherType does not conform to the protocol

Using Generics with Protocol Constraints: If you create your own collection or function, you can use generics with protocol constraints.

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 of only SubtypeA that conform to SpecificType
// var invalidArray = RestrictedArray<AnotherType>() // Compilation error, AnotherType does not conform to the protocol

Using an Enumeration (Enum) with Associated Values: If the number of subtypes is fixed and known in advance, you can use an enum.

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())) // Type error inside the associated value

Thus, direct restriction of subtypes in a standard array [SomeType] is not possible. Instead, protocols, generics with constraints, or enums are used to ensure static type safety.