Swift: Überprüfen Sie, ob der generische Typ dem Protokoll entspricht

Ich habe ein Protokoll, das ich so definiert habe:

protocol MyProtocol {
   ...
}

Ich habe auch eine generische Struktur:

struct MyStruct <T>  {
    ...
}

Endlich habe ich eine generische Funktion:

func myFunc <T> (s: MyStruct<T>) -> T? {
   ...
}

Ich möchte innerhalb der Funktion testen, ob der Typ T MyProtocol entspricht. Im Wesentlichen möchte ich in der Lage sein (~ Pseudocode):

let conforms = T.self is MyProtocol

Dies führt jedoch zu einem Compilerfehler:

error: cannot downcast from 'T.Type' to non-@objc protocol type 'MyProtocol'
   let conforms = T.self is MyProtocol
                  ~~~~~~ ^  ~~~~~~~~~~

Ich habe auch Variationen ausprobiert, wie T.self is MyProtocol.self, T is MyProtocolund die Verwendung ==statt is. Bisher bin ich nirgendwo hingekommen. Irgendwelche Ideen?

Ich muss sagen, @Alex möchte überprüfen, ob der TTyp dem Protokoll entspricht und nicht s. Und einige Antwortende sahen nicht klar.

Überprüfen Sie T, ob der Typ dem folgenden Protokoll entspricht:

if let _ = T.self as? MyProtocol.Type {
    //  T conform MyProtocol
}

oder

if T.self is MyProtocol.Type {
    //  T conform MyProtocol
}

Ein bisschen spät, aber Sie können testen, ob etwas mit dem as ?Test auf das Protokoll reagiert :

if let currentVC = myViewController as? MyCustomProtocol {
    // currentVC responds to the MyCustomProtocol protocol =]
}

EDIT: etwas kürzer:

if let _ = self as? MyProtocol {
    // match
}

Und mit einer Wache:

guard let _ = self as? MyProtocol else {
    // doesn't match
    return
}

Die einfachste Antwort lautet: Tu das nicht. Verwenden Sie stattdessen Überladung und Einschränkungen und bestimmen Sie alles zur Kompilierungszeit im Voraus, anstatt zur Laufzeit dynamisch zu testen. Runtime Type Checking und Generika zur Kompilierungszeit sind wie Steak und Eis - beide sind nett, aber das Mischen ist etwas seltsam.

Betrachten Sie so etwas:

protocol MyProtocol { }

struct MyStruct <T>  { let val: T }

func myFunc<T: MyProtocol>(s: MyStruct<T>) -> T? {
    return s.val
}

func myFunc<T>(s: MyStruct<T>) -> T? {
    return nil
}

struct S1: MyProtocol { }
struct S2 { }

let m1 = MyStruct(val: S1())
let m2 = MyStruct(val: S2())

myFunc(m1) // returns an instance of S1
myFunc(m2) // returns nil, because S2 doesn't implement MyProtocol

Der Nachteil ist, dass Sie nicht dynamisch feststellen können, ob T zur Laufzeit ein Protokoll unterstützt:

let o: Any = S1()
let m3 = MyStruct(val: o)
myFunc(m3)  // will return nil even though o 
            // does actually implement MyProtocol

Aber, ganz ehrlich, müssen Sie das wirklich in Ihrer generischen Funktion tun? Wenn Sie sich nicht sicher sind, um welchen Typ es sich tatsächlich handelt, ist es möglicherweise besser, dies im Voraus herauszufinden, als es auf einen späteren Zeitpunkt zu verschieben und es in einer generischen Funktion zu finden, um dies herauszufinden.

Sie können auch den Switch Case Pattern Matching von Swift nutzen , wenn Sie mehrere Fälle vom Typ behandeln möchten T:

func myFunc<T>(s: MyStruct<T>) -> T? {
    switch s {
    case let sType as MyProtocol:
        // do MyProtocol specific stuff here, using sType
    default:
        //this does not conform to MyProtocol
    ...
    }
}

let konform = T.self ist MyProtocol.Type

Sie müssen das Protokoll wie folgt deklarieren @objc:

@objc protocol MyProtocol {
    ...
} 

Aus Apples Buch "The Swift Programming Language":

Sie können die Protokollkonformität nur überprüfen, wenn Ihr Protokoll mit dem Attribut @objc gekennzeichnet ist, wie im obigen HasArea-Protokoll dargestellt. Dieses Attribut gibt an, dass das Protokoll dem Objective-C-Code ausgesetzt werden soll, und wird unter Verwenden von Swift mit Cocoa und Objective-C beschrieben. Auch wenn Sie nicht mit Objective-C zusammenarbeiten, müssen Sie Ihre Protokolle mit dem Attribut @objc markieren, wenn Sie die Protokollkonformität überprüfen möchten.

Beachten Sie auch, dass @ objc-Protokolle nur von Klassen und nicht von Strukturen oder Aufzählungen übernommen werden können. Wenn Sie Ihr Protokoll als @objc markieren, um die Konformität zu überprüfen, können Sie dieses Protokoll nur auf Klassentypen anwenden.

Eine moderne Antwort lautet wie folgt: (Swift 5.1)

func myFunc < T: MyProtocol> (s: MyStruct<T>) -> T? {    ... }

Für Testfälle überprüfe ich die Konformität wie folgt:

let conforms: Bool = (Controller.self as Any) is Protocol.Type