Existential Types and Generics with Protocols Logic Swift 2

Question

I am trying to learn to how generics act in Compile and RunTime stages comparing with Protocols. I know how to protocols react with existential types. Protocols are existential types so in compile stages step by step they taking the the Car type

struct Car: Drivable {
    let numberOfWheels = 4

    func drive() { }
}

car = 
    payload_data_0 = 0x0000000000000004, 
    payload_data_1 = 0x0000000000000000, 
    payload_data_2 = 0x0000000000000000, 
    instance_type = 0x000000010b50e410 
        ExistentialContainers`type metadata for 
        ExistentialContainers.Car,
    protocol_witness_0 = 0x000000010b50e1c8 
        ExistentialContainers`protocol witness table for 
        ExistentialContainers.Car: ExistentialContainers.Drivable 
        in ExistentialContainers)

What about generics ? I really wonder how act in compile and runtime stages. They use pointers right ? when at Compile time ? In runtime everything is ready for Generics.

Also this example seems same but one is compile other is not..

protocol Returnable {
    associateType ReturnType
}
//This will compile
func returnTheType<T: Returnable>(object: T) -> T.ReturnType { } ✅
//This won't compile
func returnTheType(object: Returnable) -> object.ReturnType { }  ❌

Answer 1

func startTravelingWithCar(transportation: Car) { }

I suppose you have a function like this so,

Behind the scenes the function also receives the car’s PWT and VWT, giving the function the necessary information to be able to set up a value buffer if necessary and determine the car object’s protocol specific function implementation of drive(). This newly generated function is now type specific, giving you access to any associated types of the Car object and all of this type information is determined at compile time — which is part of the reason why we can have an associated type be the return type of a generic function, but can’t do the same for protocol based functions.