Erweiterung, mit der Wrapper, die sich selbst ausgeben, als Selbst eingegeben werden

Entschuldigung für den seltsamen Titel. Hier ist eine Spielzeugskizze meines Codes:

extension UIControl {
    func makeHolder() -> ControlHolder {
        ControlHolder(control: self)
    }
}

struct ControlHolder {
    let control : UIControl
    init(control: UIControl) {
        self.control = control
    }
    func retrieve() -> UIControl {
        return self.control
    }
}

Ich gebe zu, dass dies eine Spielzeugreduktion ist, und ich mag es nicht, wenn Leute das tun, aber es veranschaulicht das syntaktische Problem perfekt, also lasst uns damit anfangen.

Okay, wir haben also eine Erweiterung für UIControl, eine Methode, die ein Wrapper-Objekt zurückgibt. Das Problem ist nun folgendes:

let holder = UISwitch().makeHolder()
let output = holder.retrieve()

Das Ergebnis outputwird offensichtlich als UIControl eingegeben. Aber das will ich nicht. Ich möchte, dass es als UISwitch eingegeben wird, da ich mit einem UISwitch begonnen habe. OK, das klingt nach einem Generikum. Das Problem ist, ich kann nicht herausfinden, wie man das generisch macht.

Ich denke, es ist einfach, ControlHolder zu einem Generikum zu machen:

struct ControlHolder<T:UIControl> {
    let control : T
    init(control: T) {
        self.control = control
    }
    func retrieve() -> T {
        return self.control
    }
}

Ich bin mir ziemlich sicher, dass ich diesen Teil richtig verstanden habe. Aber wie schreibe ich dann die Erweiterungsdeklaration so, dass diese generische in den tatsächlichen Typ des selfUIControl aufgelöst wird, auf dem makeHolderaufgerufen wird?

Ich habe versucht, ein Generikum in die Erweiterung einzuführen, wobei ich dem Compiler gehorchte, bis ich es zum Kompilieren bekam:

extension UIControl {
    func makeHolder<T>() -> ControlHolder<T> {
        ControlHolder<T>(control: self as! T)
    }
}

Aber das ist ziemlich albern und outputwird immer noch als UIControl eingegeben.

Natürlich kann ich einen weiteren Parameter hinzufügen, der den Typ explizit übergibt makeHolderund ihn somit auflöst:

extension UIControl {
    func makeHolder<T>(ofType: T.Type) -> ControlHolder<T> {
        ControlHolder<T>(control: self as! T)
    }
}

Wenn ich jetzt anrufe, gebe makeHolderich den Typ ein:

let holder = UISwitch().makeHolder(ofType: UISwitch.self)
let output = holder.retrieve()

Und jetzt wird natürlich outputals UISwitch getippt. Aber das ist idiotisch! Ich möchte, dass die Erweiterung nur weiß, dass der Typ UISwitch ist, da ich makeHoldereinen UISwitch aufrufe.

Ich habe das Gefühl, dass ich das alles falsch verstehe. Vielleicht kann mich jemand begradigen? Oder strebe ich etwas an, das einfach unmöglich ist?