"ambiguous for type lookup" problem

Question

djape OP

Created Sep ’15

Replies 2

Boosts 0

Views 14k

Participants 2

I need help with understanding protocols with associated types.

Why this code doesn't compile:

protocol A {
  typealias AssociatedType
}

extension A where Self: MyClass {
  func f(x: AssociatedType) { //'AssociatedType' is ambiguous for type lookup...
    // do stuff
  }
}

class MyClass: A {
  typealias AssociatedType = Int
}

but it works when class is replaced with subclass

protocol A {
  typealias AssociatedType
}

extension A where Self: MyClass {
  func f(x: AssociatedType) {
    // do stuff
  }
}

class MySubclass: MyClass, A {
  typealias AssociatedType = Int
}

Answered by OOPer in 64011022

An interesting example.

In your first code, two AssociatedTypes are available in the extension context. A.AssociatedType and MyClass.AssociatedType .

(`A.AssociatedType` is not a valid representation outside the protocol A, but it's another issue.)

And, it seems Swift cannot utilize the fact that two AssociatedTypes are the same. So complaining about they are `ambiguous`.

In your second code, you are omitting the definition of MyClass, so assuming:

class MyClass {}

In this case, in the extension context, AssociatedType can only represent A.AssociatedType, so Swift compiler does not complain.

With modifying your code by specifying which AssociatedType you mean, you can make Swift silent:

extension A where Self: MyClass {
    func f(x: MyClass.AssociatedType) {
        // do stuff
    }
}

Boost

Answer 1

OOPer OP

Sep ’15

Accepted Answer