Wie testen Sie Funktionen und Verschlüsse auf Gleichheit?

Das Buch sagt, dass "Funktionen und Verschlüsse Referenztypen sind". Wie finden Sie heraus, ob die Referenzen gleich sind? == und === funktionieren nicht.

func a() { }
let å = a
let b = å === å // Could not find an overload for === that accepts the supplied arguments

Chris Lattner schrieb in den Entwicklerforen:

Dies ist eine Funktion, die wir absichtlich nicht unterstützen möchten. Es gibt eine Vielzahl von Faktoren, die dazu führen, dass die Gleichheit der Funktionen von Zeigern (im Sinne eines schnellen Systems, das verschiedene Arten von Verschlüssen umfasst) je nach Optimierung fehlschlägt oder sich ändert. Wenn "===" für Funktionen definiert wäre, könnte der Compiler keine identischen Methodenkörper zusammenführen, Thunks gemeinsam nutzen und bestimmte Erfassungsoptimierungen in Closures durchführen. Darüber hinaus wäre eine solche Gleichheit in einigen generischen Kontexten äußerst überraschend, in denen Sie Reabstraktions-Thunks erhalten können, die die tatsächliche Signatur einer Funktion an die vom Funktionstyp erwartete anpassen.

https://devforums.apple.com/message/1035180#1035180

Dies bedeutet, dass Sie nicht einmal versuchen sollten, Abschlüsse auf Gleichheit zu vergleichen, da Optimierungen das Ergebnis beeinflussen können.

Ich habe viel gesucht. Es scheint keine Möglichkeit zum Vergleich von Funktionszeigern zu geben. Die beste Lösung besteht darin, die Funktion oder den Abschluss in einem hashbaren Objekt zu kapseln. Mögen:

var handler:Handler = Handler(callback: { (message:String) in
            //handler body
}))

Einfachste Weg ist , den Blocktyp bezeichnen , wie @objc_block, und jetzt können Sie es zu einem ANYOBJECT gegossen , die mit vergleichbar ist ===. Beispiel:

    typealias Ftype = @objc_block (s:String) -> ()

    let f : Ftype = {
        ss in
        println(ss)
    }
    let ff : Ftype = {
        sss in
        println(sss)
    }
    let obj1 = unsafeBitCast(f, AnyObject.self)
    let obj2 = unsafeBitCast(ff, AnyObject.self)
    let obj3 = unsafeBitCast(f, AnyObject.self)

    println(obj1 === obj2) // false
    println(obj1 === obj3) // true

Ich habe auch nach der Antwort gesucht. Und ich habe es endlich gefunden.

• https://gist.github.com/dankogai/b03319ce427544beb5a4

Was Sie brauchen, ist der eigentliche Funktionszeiger und sein im Funktionsobjekt versteckter Kontext.

func peekFunc<A,R>(f:A->R)->(fp:Int, ctx:Int) {
    typealias IntInt = (Int, Int)
    let (hi, lo) = unsafeBitCast(f, IntInt.self)
    let offset = sizeof(Int) == 8 ? 16 : 12
    let ptr  = UnsafePointer<Int>(lo+offset)
    return (ptr.memory, ptr.successor().memory)
}
@infix func === <A,R>(lhs:A->R,rhs:A->R)->Bool {
    let (tl, tr) = (peekFunc(lhs), peekFunc(rhs))
    return tl.0 == tr.0 && tl.1 == tr.1
}

Und hier ist die Demo:

// simple functions
func genericId<T>(t:T)->T { return t }
func incr(i:Int)->Int { return i + 1 }
var f:Int->Int = genericId
var g = f;      println("(f === g) == \(f === g)")
f = genericId;  println("(f === g) == \(f === g)")
f = g;          println("(f === g) == \(f === g)")
// closures
func mkcounter()->()->Int {
    var count = 0;
    return { count++ }
}
var c0 = mkcounter()
var c1 = mkcounter()
var c2 = c0
println("peekFunc(c0) == \(peekFunc(c0))")
println("peekFunc(c1) == \(peekFunc(c1))")
println("peekFunc(c2) == \(peekFunc(c2))")
println("(c0() == c1()) == \(c0() == c1())") // true : both are called once
println("(c0() == c2()) == \(c0() == c2())") // false: because c0() means c2()
println("(c0 === c1) == \(c0 === c1)")
println("(c0 === c2) == \(c0 === c2)")

In den folgenden URLs erfahren Sie, warum und wie es funktioniert:

• https://github.com/rodionovd/SWRoute/wiki/Function-hooking-in-Swift
• https://github.com/rodionovd/SWRoute/blob/master/SWRoute/rd_get_func_impl.c

Wie Sie sehen, kann nur die Identität überprüft werden (der 2. Test ergibt false). Das sollte aber gut genug sein.

Dies ist eine großartige Frage, und obwohl Chris Lattner diese Funktion absichtlich nicht unterstützen möchte, kann ich, wie viele Entwickler, auch meine Gefühle aus anderen Sprachen nicht loslassen, in denen dies eine triviale Aufgabe ist. Es gibt viele unsafeBitCastBeispiele, von denen die meisten nicht das vollständige Bild zeigen. Hier ist ein detaillierteres :

typealias SwfBlock = () -> ()
typealias ObjBlock = @convention(block) () -> ()

func testSwfBlock(a: SwfBlock, _ b: SwfBlock) -> String {
    let objA = unsafeBitCast(a as ObjBlock, AnyObject.self)
    let objB = unsafeBitCast(b as ObjBlock, AnyObject.self)
    return "a is ObjBlock: \(a is ObjBlock), b is ObjBlock: \(b is ObjBlock), objA === objB: \(objA === objB)"
}

func testObjBlock(a: ObjBlock, _ b: ObjBlock) -> String {
    let objA = unsafeBitCast(a, AnyObject.self)
    let objB = unsafeBitCast(b, AnyObject.self)
    return "a is ObjBlock: \(a is ObjBlock), b is ObjBlock: \(b is ObjBlock), objA === objB: \(objA === objB)"
}

func testAnyBlock(a: Any?, _ b: Any?) -> String {
    if !(a is ObjBlock) || !(b is ObjBlock) {
        return "a nor b are ObjBlock, they are not equal"
    }
    let objA = unsafeBitCast(a as! ObjBlock, AnyObject.self)
    let objB = unsafeBitCast(b as! ObjBlock, AnyObject.self)
    return "a is ObjBlock: \(a is ObjBlock), b is ObjBlock: \(b is ObjBlock), objA === objB: \(objA === objB)"
}

class Foo
{
    lazy var swfBlock: ObjBlock = self.swf
    func swf() { print("swf") }
    @objc func obj() { print("obj") }
}

let swfBlock: SwfBlock = { print("swf") }
let objBlock: ObjBlock = { print("obj") }
let foo: Foo = Foo()

print(testSwfBlock(swfBlock, swfBlock)) // a is ObjBlock: false, b is ObjBlock: false, objA === objB: false
print(testSwfBlock(objBlock, objBlock)) // a is ObjBlock: false, b is ObjBlock: false, objA === objB: false

print(testObjBlock(swfBlock, swfBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: false
print(testObjBlock(objBlock, objBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: true

print(testAnyBlock(swfBlock, swfBlock)) // a nor b are ObjBlock, they are not equal
print(testAnyBlock(objBlock, objBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: true

print(testObjBlock(foo.swf, foo.swf)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: false
print(testSwfBlock(foo.obj, foo.obj)) // a is ObjBlock: false, b is ObjBlock: false, objA === objB: false
print(testAnyBlock(foo.swf, foo.swf)) // a nor b are ObjBlock, they are not equal
print(testAnyBlock(foo.swfBlock, foo.swfBlock)) // a is ObjBlock: true, b is ObjBlock: true, objA === objB: true

Der interessante Teil ist, wie schnell SwfBlock frei in ObjBlock umgewandelt wird, aber in Wirklichkeit haben zwei gegossene SwfBlock-Blöcke immer unterschiedliche Werte, während ObjBlocks dies nicht tun. Wenn wir ObjBlock in SwfBlock umwandeln, passiert ihnen dasselbe, sie werden zu zwei verschiedenen Werten. Um die Referenz zu erhalten, sollte diese Art des Gießens vermieden werden.

Ich verstehe das ganze Thema immer noch, aber eine Sache, die ich mir noch gewünscht habe, ist die Fähigkeit, @convention(block)Klassen- / Strukturmethoden zu verwenden. Deshalb habe ich eine Feature-Anfrage eingereicht, die eine Abstimmung erfordert oder erklärt, warum dies eine schlechte Idee ist. Ich habe auch das Gefühl, dass dieser Ansatz insgesamt schlecht sein könnte. Wenn ja, kann jemand erklären, warum?

Hier ist eine mögliche Lösung (konzeptionell die gleiche wie die Antwort "tuncay"). Der Punkt besteht darin, eine Klasse zu definieren, die einige Funktionen einschließt (z. B. Befehl):

Schnell:

typealias Callback = (Any...)->Void
class Command {
    init(_ fn: @escaping Callback) {
        self.fn_ = fn
    }

    var exec : (_ args: Any...)->Void {
        get {
            return fn_
        }
    }
    var fn_ :Callback
}

let cmd1 = Command { _ in print("hello")}
let cmd2 = cmd1
let cmd3 = Command { (_ args: Any...) in
    print(args.count)
}

cmd1.exec()
cmd2.exec()
cmd3.exec(1, 2, "str")

cmd1 === cmd2 // true
cmd1 === cmd3 // false

Java:

interface Command {
    void exec(Object... args);
}
Command cmd1 = new Command() {
    public void exec(Object... args) [
       // do something
    }
}
Command cmd2 = cmd1;
Command cmd3 = new Command() {
   public void exec(Object... args) {
      // do something else
   }
}

cmd1 == cmd2 // true
cmd1 == cmd3 // false

Nun, es sind 2 Tage vergangen und niemand hat eine Lösung gefunden, also werde ich meinen Kommentar in eine Antwort ändern:

Soweit ich das beurteilen kann, können Sie die Gleichheit oder Identität von Funktionen (wie in Ihrem Beispiel) und Metaklassen (z. B.) nicht überprüfen MyClass.self:

Aber - und das ist nur eine Idee - ich kann nicht anders, als zu bemerken, dass die whereKlausel in Generika in der Lage zu sein scheint, die Gleichheit der Typen zu überprüfen. Vielleicht können Sie das nutzen, zumindest um die Identität zu überprüfen?

Keine allgemeine Lösung, aber wenn man versucht, ein Listener-Muster zu implementieren, habe ich während der Registrierung eine "ID" der Funktion zurückgegeben, damit ich sie später abmelden kann (was eine Art Problemumgehung für die ursprüngliche Frage darstellt Für den Fall "Zuhörer" kommt es normalerweise darauf an, die Funktionen auf Gleichheit zu überprüfen, was nach anderen Antworten zumindest nicht "trivial" ist.

Also so etwas wie das:

class OfflineManager {
    var networkChangedListeners = [String:((Bool) -> Void)]()

    func registerOnNetworkAvailabilityChangedListener(_ listener: @escaping ((Bool) -> Void)) -> String{
        let listenerId = UUID().uuidString;
        networkChangedListeners[listenerId] = listener;
        return listenerId;
    }
    func unregisterOnNetworkAvailabilityChangedListener(_ listenerId: String){
        networkChangedListeners.removeValue(forKey: listenerId);
    }
}

Jetzt müssen Sie nur noch die keyvon der Funktion "register" zurückgegebene Funktion speichern und beim Aufheben der Registrierung übergeben.

Meine Lösung bestand darin, Funktionen in eine Klasse zu verpacken, die NSObject erweitert

class Function<Type>: NSObject {
    let value: (Type) -> Void

    init(_ function: @escaping (Type) -> Void) {
        value = function
    }
}

Ich weiß, dass ich diese Frage sechs Jahre zu spät beantworte, aber ich denke, es lohnt sich, die Motivation hinter der Frage zu betrachten. Der Fragesteller kommentierte:

Ohne Verschlüsse aus einer Aufrufliste als Referenz entfernen zu können, müssen wir jedoch unsere eigene Wrapper-Klasse erstellen. Das ist eine Belastung und sollte nicht notwendig sein.

Ich denke, der Fragesteller möchte eine Rückrufliste wie folgt führen:

class CallbackList {
    private var callbacks: [() -> ()] = []

    func call() {
        callbacks.forEach { $0() }
    }

    func addCallback(_ callback: @escaping () -> ()) {
        callbacks.append(callback)
    }

    func removeCallback(_ callback: @escaping () -> ()) {
        callbacks.removeAll(where: { $0 == callback })
    }
}

Aber wir können nicht so schreiben removeCallback, weil ==es für Funktionen nicht funktioniert. (Auch nicht ===.)

Hier ist eine andere Möglichkeit, Ihre Rückrufliste zu verwalten. Geben Sie ein Registrierungsobjekt von zurück addCallbackund entfernen Sie den Rückruf mithilfe des Registrierungsobjekts. Hier im Jahr 2020 können wir die Kombinate AnyCancellableals Registrierung verwenden.

Die überarbeitete API sieht folgendermaßen aus:

class CallbackList {
    private var callbacks: [NSObject: () -> ()] = [:]

    func call() {
        callbacks.values.forEach { $0() }
    }

    func addCallback(_ callback: @escaping () -> ()) -> AnyCancellable {
        let key = NSObject()
        callbacks[key] = callback
        return .init { self.callbacks.removeValue(forKey: key) }
    }
}

Wenn Sie jetzt einen Rückruf hinzufügen, müssen Sie ihn nicht mehr behalten, um ihn removeCallbackspäter weiterzuleiten . Es gibt keine removeCallbackMethode. Stattdessen speichern Sie die AnyCancellableund rufen ihre cancelMethode auf, um den Rückruf zu entfernen. Noch besser, wenn Sie die AnyCancellableEigenschaft in einer Instanz speichern , bricht sie sich automatisch ab, wenn die Instanz zerstört wird.