Swift 中的协议向下转换

Question

I have the following code:

protocol Step { /* body */ }

enum StepA: Int, CaseIterable, Step {
    case one
    case two
    case three
}

enum StepB: Int, CaseIterable, Step {
    case one
    case two
    case three
}

protocol Component {
    var step: Step { get }
}

protocol ComponentA: Component {
    var step: StepA { get }
}

protocol ComponentB: Component {
    var step: StepB { get }
}


struct SomeComponentOfTypeA: ComponentA {
    var step: StepA = StepA.one
}


let a = SomeComponentOfTypeA()

print(a.step)

The type of a.step I would like to be StepA , since I am initalizing this way. But, I can't do that because:

struct SomeComponentOfTypeA: ComponentA {
    var step: StepA = StepA.one
}

the compiler tells me that:

Type 'SomeComponentOfTypeA' does not conform to protocol 'Component'

Basically, it doesn't know that since I am implementing the ComponentA , my step should be of type StepA too.

As a workaround I found that if I modify this part:

protocol Component {
    var step: Step { get }
}

into:

protocol Component {
    associatedtype SomeStep: Step
    var step: SomeStep { get }
}

Everything works just fine, a.step is of StepA , no issues at all...

Question: why is this working? I am basically hiding the fact that step property from Component is of type Step , by using the associated type SomeStep . This is kinda weird, isn't it? I was expecting this to work just fine without having to hide anything, why is this happening? How does it work?

Thanks. Any help would be much appreciated!

Answer 1

Do you really need all the protocols? You could do this with associated values:

protocol Step { /* body */ }

enum StepA: Int, CaseIterable, Step {
    case one
    case two
    case three
}

enum StepB: Int, CaseIterable, Step {
    case one
    case two
    case three
}

enum Component {
    case typeA(StepA)
    case typeB(StepB)
}

let component = Component.typeA(StepA.one)

Answer 2

The mistake is in the way the protocols are defined.

1. Protocol Component has a variable step of type Step (a protocol)
2. The variable step gets redeclared in protocol ComponentA
3. So when defining SomeComponentOfTypeA the compiler gives an error as it finds step of type StepA per ComponentA but not of type Step per Component protocol.
4. When you define AssociatedType, you then make use of generics to specify that step variable in Component can be of any type following protocol Step
5. So now ComponentA's step variable satisfies point 4 and hence no error.

And therefore, what you did finally using generics is the right approach for such a case, if you really wanted to redeclare the variable step in ComponentA for a specific type StepA .

Answer 3

Protocol can be adopted by a struct or enum so it don't do class polymorphism, because they can not be inherited. This is also one of the reasons that why associatedtype exists.

Back to your question, you defined a variable with the same name as the parent protocol in the sub-protocol, but the type is different, this is allowed because the protocol is not a concrete type. But this is not a type overload, because the protocol works differently from the class.

In this case, you'd better use generics, which is associatedtype . But if you have to use these three protocols, you only need to declare the sub-protocol.

...

protocol ComponentA: Component {}

protocol ComponentB: Component {}

struct SomeComponentOfTypeA: ComponentA {
  var step: Step = StepA.one
}

struct SomeComponentOfTypeB: ComponentB {
  var step: Step = StepB.two
}

let a = SomeComponentOfTypeA()

print(a.step)
print(type(of: a))

let b = SomeComponentOfTypeB()

print(b.step)
print(type(of: b))

Output:

one
SomeComponentOfTypeA
two
SomeComponentOfTypeB

Another way is to meet your needs. Limit SomeComponentOfTypeA only allows StepA type.

protocol StepAProtocol { /* body */ }
protocol StepBProtocol { /* body */ }

enum StepA: Int, CaseIterable, StepAProtocol {
    case one
    case two
    case three
}

enum StepB: Int, CaseIterable, StepBProtocol {
    case one
    case two
    case three
}

protocol Component {
  associatedtype T
  var step: T { get }
}

protocol ComponentA: Component where T: StepAProtocol  {}
protocol ComponentB: Component where T: StepBProtocol  {}

struct SomeComponentOfTypeA: ComponentA {
  var step: StepA = .one
}

struct SomeComponentOfTypeB: ComponentB {
  var step: StepB = .two
}

struct SomeComponentOfTypeC: ComponentB {
  var step: StepA = .two // error: Type 'StepA' does not conform to protocol 'StepBProtocol'
}