如何在Swift中将type（of：someVar）用作适当的Type？

Question

How can I use type(of: someVar) as a proper Type in Swift?

Suppose I have some generic protocol Requestable:

protocol Decryptable: Decodable {
    var cipher: Cipher
}
protocol Requestable {
    associatedtype T
    var schema: T
}
protocol Service {
    static func invoke<R: Requestable>(_ request: R) -> Void where R.T: Decodable {
    // impl. #1
    }
    static func invoke<R: Requestable>(_ request: R) -> Void where R.T: Decryptable {
    // impl. #2
    }
}
struct Request<T>: Requestable {
    var schema: T
}

Service can invoke a Request whose Schema is Decodable or Decryptable.

However, since Decryptable conforms to Decodable, elsewhere we have some Decryptable value that has been upcast to Decodable like:

let myDecodable = myDecryptable as Decodable
// later... in a class that doesn’t know about myDecryptable...
let myRequest = Request(schema: myDecodable)
Service.invoke(myRequest)

Now, when Service invoke gets called here, it will route to the first implementation (#1). Ie, since the request has been created with the upcasted value “myDecodable”, invoke will go to implementation #1 (as if Request.T is only some Decodable type, when in fact it's Decryptable, under the hood).

Indeed, if I set breakpoints in XCode, the runtime clearly knows that Request.T is a Decryptable type in every situation, even after is was upcast.

So inside implementation 1, I tried many things to route a call where the schema is Decryptable to implementation 2:

typealias ActualType: Decryptable = R.T
if let downcastedRequest = request as? Request<ActualType> {
     invoke(downcastedRequest)
}
// FAILS to compile    

let schemaType = type(of: request.schema)
if let downcastedRequest = Request<schemaType>(schema: request.schema as? schemaType)  {
     invoke(downcastedRequest)
}
// FAILS to compile


if let downcastedRequest = Request<type(of: request.schema)>(schema: request.schema as? type(of: request.schema))  {
     invoke(downcastedRequest)
}
// FAILS to compile

Please help, thanks. (Was I stupid to try to use protocols with associated types? Why can't I use type(of: schema) as if it were a proper Type here..?

Answer 1

Use == instead of :

<...>
where R.T == Decodable <...>
where R.T == Decryptable <...>