Declaring a Property with Type Constraint in Swift

I need to create a custom fields framework in my app. I defined a protocol for the fields called FieldType and extended with it UITextField and UIButton to be different types of fields.

Now I want to create a container view for the fields so I want the container to be able to refer to its field elements as both UIViews and FieldTypes, and I'm wondering if there's a concise way to define the type of elements it receives to be a specific UIView that implements the FieldType protocol?

I can have FieldContainerView accept UIViews or FieldTypes and check manually that it also matches the other with a guard statement, but it feels a bit cumbersome.

I tried 2 approaches:

1) Define a Custom Intermediary FieldViewType

The idea is to have FieldViewType extend UIView directly with FieldType so it might be useful as a general case for UITextField: FieldType and UIButton: FieldType. But as this code sample clearly shows, this does not work.

protocol FieldType {
  var showError: Bool { get set }
  var isEmpty: Bool { get set }
}

class CustomTextField: UITextField, FieldType {}
class CustomButtonField: UIButton, FieldType {}

let textField = CustomTextField()
textField is UIView       // True
textField is FieldType    // True

let buttonField = CustomButtonField()
buttonField is UIView     // True
buttonField is FieldType  // True

class FieldView: UIView, FieldProtocol {}

let field = FieldView()
field is UIView           // True
field is FieldProtocol    // True

textField is FieldView    // False
buttonField is FieldView  // False

2) Use Generics

I can define a generic type that matches the requirements like so <FieldViewType: UIView where FieldViewType: FieldType>, but I don't see where to use to best solve my problem. If I define it at the class level

class FieldContainerView<FieldViewType: UIView where FieldViewType: FieldType>: UIView {
  var fields = [FieldViewType]()
  func addField(FieldViewType: field) {
    fields.append(field)
  }
}

I need to declare the container class once for each field type I'll want to use and won't be able to use 2 field types in the same container.

The other option is to define type constraint at the function level with addField

class FieldContainerView: UIView {
  var fields = [UIView]()
  func addField<FieldViewType: UIView where FieldViewType: FieldType>(FieldViewType: field) {
    fields.append(field)
  }
}

and then cast each element in fields to FieldType when necessary and I'll know the cast will always work because addField is the only way to add elements to the container. But this also feels too cumbersome.

It feels like the best way around this would have been to be able to define FieldViewType with a typealias, but this doesn't seem to be supported. Or have UIView be defined with a protocol so it could be mixed better, but UIKit isn't constructed in this manner.