Come testate le funzioni e le chiusure per l'uguaglianza?

Il libro dice che "le funzioni e le chiusure sono tipi di riferimento". Allora, come fai a scoprire se i riferimenti sono uguali? == e === non funzionano.

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

Chris Lattner ha scritto sui forum degli sviluppatori:

Questa è una funzionalità che intenzionalmente non vogliamo supportare. Ci sono una varietà di cose che causeranno il fallimento o la modifica dell'uguaglianza delle funzioni del puntatore (nel senso di sistema di tipo rapido, che include diversi tipi di chiusure) a seconda dell'ottimizzazione. Se "===" fosse definito sulle funzioni, al compilatore non sarebbe consentito unire corpi di metodo identici, condividere thunk ed eseguire determinate ottimizzazioni di acquisizione nelle chiusure. Inoltre, l'uguaglianza di questo tipo sarebbe estremamente sorprendente in alcuni contesti generici, in cui è possibile ottenere thunk di riabstrazione che regolano la firma effettiva di una funzione a quella prevista dal tipo di funzione.

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

Ciò significa che non dovresti nemmeno provare a confrontare le chiusure per l'uguaglianza perché le ottimizzazioni possono influenzare il risultato.

Ho cercato molto. Non sembra esserci alcun modo per confrontare il puntatore di funzione. La soluzione migliore che ho ottenuto è incapsulare la funzione o la chiusura in un oggetto hashable. Piace:

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

Il modo più semplice è designare il tipo di blocco come @objc_block, e ora puoi lanciarlo a un AnyObject che è paragonabile a ===. Esempio:

    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

Anch'io ho cercato la risposta. E finalmente l'ho trovato.

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

Ciò di cui hai bisogno è il puntatore alla funzione effettivo e il suo contesto nascosto nell'oggetto funzione.

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
}

Ed ecco la 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)")

Vedere gli URL di seguito per scoprire perché e come funziona:

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

Come vedi, è in grado di controllare solo l'identità (il 2 ° test restituisce false). Ma dovrebbe essere abbastanza buono.

Questa è una grande domanda e anche se Chris Lattner non vuole intenzionalmente supportare questa funzione, io, come molti sviluppatori, non posso lasciare andare i miei sentimenti provenienti da altre lingue in cui questo è un compito banale. Ci sono molti unsafeBitCastesempi, la maggior parte di loro non mostra il quadro completo, eccone uno più dettagliato :

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

La parte interessante è come swift lancia liberamente SwfBlock su ObjBlock, ma in realtà due blocchi SwfBlock lanciati avranno sempre valori diversi, mentre ObjBlocks no. Quando lanciamo ObjBlock a SwfBlock, succede loro la stessa cosa, diventano due valori diversi. Quindi, al fine di preservare il riferimento, questo tipo di fusione dovrebbe essere evitato.

Sto ancora comprendendo l'intero argomento, ma una cosa che ho lasciato desiderare è la capacità di utilizzare @convention(block)sui metodi class / struct, quindi ho presentato una richiesta di funzionalità che necessita di un voto positivo o di spiegare perché è una cattiva idea. Ho anche la sensazione che questo approccio potrebbe essere cattivo tutto insieme, se è così, qualcuno può spiegare perché?

Ecco una possibile soluzione (concettualmente la stessa della risposta "tuncay"). Il punto è definire una classe che racchiuda alcune funzionalità (ad esempio Command):

Swift:

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

Giava:

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

Sono passati 2 giorni e nessuno è intervenuto con una soluzione, quindi cambierò il mio commento in una risposta:

Per quanto ne so, non puoi controllare l'uguaglianza o l'identità di funzioni (come il tuo esempio) e metaclassi (ad es. MyClass.self):

Ma - e questa è solo un'idea - non posso fare a meno di notare che la whereclausola dei generici sembra essere in grado di controllare l'uguaglianza dei tipi. Quindi forse puoi sfruttarlo, almeno per controllare l'identità?

Non è una soluzione generale, ma se si sta tentando di implementare un modello di ascolto, ho finito per restituire un "id" della funzione durante la registrazione in modo da poterlo utilizzare per annullare la registrazione in un secondo momento (cheèuna sorta di soluzione alternativa alla domanda originale per il caso "ascoltatori", come di solito l'annullamento della registrazione si riduce al controllo dell'uguaglianza delle funzioni, che almeno non è "banale" come per altre risposte).

Quindi qualcosa del genere:

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);
    }
}

Ora devi solo memorizzare quanto keyrestituito dalla funzione "register" e passarlo all'annullamento della registrazione.

La mia soluzione era racchiudere le funzioni in una classe che estende NSObject

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

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

So che sto rispondendo a questa domanda con sei anni di ritardo, ma penso che valga la pena guardare la motivazione dietro la domanda. L'interrogante ha commentato:

Senza essere in grado di rimuovere le chiusure da un elenco di invocazioni per riferimento, tuttavia, dobbiamo creare la nostra classe wrapper. Questa è una seccatura e non dovrebbe essere necessaria.

Quindi immagino che l'interrogante voglia mantenere un elenco di richiamate, come questo:

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 })
    }
}

Ma non possiamo scrivere in removeCallbackquesto modo, perché ==non funziona per le funzioni. (Nemmeno lo fa ===.)

Ecco un modo diverso per gestire il tuo elenco di richiamate. Restituire un oggetto di registrazione da addCallbacke utilizzare l'oggetto di registrazione per rimuovere il callback. Qui nel 2020, possiamo usare le Combine AnyCancellablecome registrazione.

L'API rivista ha questo aspetto:

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) }
    }
}

Ora, quando aggiungi una richiamata, non è necessario tenerla in giro per passare a una removeCallbacksuccessiva. Non esiste un removeCallbackmetodo. Invece, si salva il AnyCancellablee si chiama il suo cancelmetodo per rimuovere il callback. Ancora meglio, se memorizzi la AnyCancellableproprietà in un'istanza, questa si annullerà automaticamente quando l'istanza viene distrutta.