why is this causing so much trouble? (protocols and typealiases on their associated types)

Question

I\'m trying to do something along the lines of this:

protocol Protocol {
    associatedtype T
    associatedtype ArrayT = Array
}

struct Struct

        

Answer 1

The line associatedtype ArrayT = Array<T> only tells the compiler that the default value of ArrayT is Array<T>. An adaption of the protocol can still change ArrayT like:

struct U: Protocol {
    typealias T = UInt32
    typealias ArrayT = UInt64   // <-- valid!
}

If you want a fixed type, you should use a typealias...

// does not work yet.
protocol Protocol {
    associatedtype T
    typealias ArrayT = Array<T>
}

But the compiler complains that the type is too complex

Answer 2

When you "initialize" an associatedtype, you're not defining it. That's not the point of associated types in the first place. Associated types are deliberately unbound ("placeholders") until the adopting class resolves them all. All you're doing there is giving it a default value, which a conforming class is allowed to override. To extend your example:

protocol Protocol {
    associatedtype T
    associatedtype ArrayT = Array<Self.T>

    func useSomeT(myFavoriteT: T)

    func useSomeArrayT(myLeastFavoriteArrayT: ArrayT)
}

class Whatever: Protocol {
    func useSomeT(myFavoriteT: Int) {
        print("My Favorite Int: \(myFavoriteT)")
    }

    func useSomeArrayT(myLeastFavoriteArrayT: [Int: String]) {
        print(myLeastFavoriteArrayT.map { $0.1 })
    }
}

struct Struct<ProtocolType: Protocol> {
    func doSomething(stuff: ProtocolType.ArrayT) {
        print(type(of: stuff))
    }
}

let x = Struct<Whatever>()
x.doSomething(stuff: [3: "Doggies"])

For your example, it seems all you really want is to declare with: Array<ProtocolType.T> (or simply with: [ProtocolType.T]) as the parameter type.