why is this causing so much trouble? (protocols an

Question

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

protocol Protocol {
    associatedtype T
    associatedtype ArrayT = Array<T>
}

struct Struct<ProtocolType: Protocol> {

    func doSomething(with: ProtocolType.ArrayT) {

        let _ = with.map { $0 } 
        // ^ compiler complains on this line
        // "value of type ProtocolType.ArrayT has no member map"
    }
}   

where I define a convenience typealias ArrayT that uses the associatedtype T. It seems that when I try to use ArrayT like in doSomething(_:), I lose the Array type information of ArrayT.

Shouldn't ArrayT definitely be an Array and therefore a member of the Sequence protocol, exposing the map function?

标签： swift swift3

举报

Answer 1

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.

Answer 2

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

查看更多

0人赞 添加讨论(0) 举报