In Swift, how to cast to protocol with associated type?

Unfortunately, Swift doesn't currently support the use of protocols with associated types as actual types. This however is technically possible for the compiler to do; and it may well be implemented in a future version of the language.

A simple solution in your case is to define a 'shadow protocol' that SpecialController derives from, and allows you to access currentValue through a protocol requirement that type erases it:

// This assumes SpecialValue doesn't have associated types – if it does, you can// repeat the same logic by adding TypeErasedSpecialValue, and then using that.protocol SpecialValue {  // ...}protocol TypeErasedSpecialController {  var typeErasedCurrentValue: SpecialValue? { get }}protocol SpecialController : TypeErasedSpecialController {  associatedtype SpecialValueType : SpecialValue  var currentValue: SpecialValueType? { get }}extension SpecialController {  var typeErasedCurrentValue: SpecialValue? { return currentValue }}extension String : SpecialValue {}struct S : SpecialController {  var currentValue: String?}var x: Any = S(currentValue: "Hello World!")if let sc = x as? TypeErasedSpecialController {  print(sc.typeErasedCurrentValue as Any) // Optional("Hello World!")}

[Edited to fix: : SpecialValue, not = SpecialValue]

This is not possible. SpecialValueController is an "incomplete type" conceptually so the compiler cannot know. SpecialValueType, although it is constrained by SpecialValue, it is not known until it is determined by any adopting class. So it is a really placeholder with inadequate information. as?-ness cannot be checked.

You could have a base class that adopts SpecialController with a concrete type for SpecialValueController, and have multiple child classes that inherit from the adopting class, if you're still seeking a degree of polymorphism.

This doesn't work because SpecialController isn't a single type. You can think of associated types as a kind of generics. A SpecialController with its SpecialValueType being an Int is a completely different type from a SpecialController with its SpecialValueType being an String, just like how Optional<Int> is a completely different type from Optional<String>.

Because of this, it doesn't make any sense to cast to SpecialValueType, because that would gloss over the associated type, and allow you to use (for example) a SpecialController with its SpecialValueType being an Int where a SpecialController with its SpecialValueType being a String is expected.

As compiler suggests, the only way SpecialController can be used is as a generic constraint. You can have a function that's generic over T, with the constraint that T must be a SpecialController. The domain of T now spans all the various concrete types of SpecialController, such as one with an Int associated type, and one with a String. For each possible associated type, there's a distinct SpecialController, and by extension, a distinct T.

To draw out the Optional<T> analogy further. Imagine if what you're trying to do was possible. It would be much like this:

func funcThatExpectsIntOptional(_: Int?) {}let x: Optional<String> = "An optional string"// Without its generic type parameter, this is an incomplete type. suppose this were validlet y = x as! OptionalfuncThatExpectsIntOptional(y) // boom.