Cosa si intende per essere "fisicamente uguali" in Haxe?

Question

Ho giocato con Neko Modules, ma penso di avere dei comportamenti inconsistenti.

var funcs = 0; 
var objs = 0; 
for (i in 0...m.globalsCount()) 
{ 
    var obj:Dynamic = m.getGlobal(i); 

    if (Reflect.compareMethods(obj, init)) 
     trace("matched"); 

    if (Reflect.isFunction(obj)) 
     funcs++; 
    else if (Reflect.isObject(obj)) 
     objs++; 
} 
trace('Functions: $funcs'); 
trace('Objects: $objs'); 

Nel codice precedente, quando lo eseguo la prima volta, ottengo un totale di 4487 funzioni. Se rimuovo una funzione, ricostruire e correre, ho l'atteso 4486.

ho aggiunto il confronto compareMethods per confrontare il obj con init, dove init è una funzione ho dichiarato nel file principale, ma la traccia non è mai uscita .

Ho dato un'occhiata al suggerimento sul codice per la funzione compareMethods e mi sono imbattuto nella seguente terminologia: if 'f1' and the 'f2' are **physically** equal.

Ora, sono entrambe le funzioni e in nessun punto del manuale di Haxe vengono menzionate le funzioni fisiche. Quindi ho una domanda in due parti, davvero.

Che cos'è una funzione fisica e come ottengo il risultato della traccia come ci si aspetterebbe in precedenza? Grazie in anticipo.

Answer 1

In base alle haxe unit test (e alla sorgente js di Reflect) Reflect.compareMethods restituisce true solo se si sta confrontando qualsiasi metodo dello stesso oggetto con se stesso.

// https://github.com/HaxeFoundation/haxe/blob/ff3d7fe6911ab84c370b1334d537a768a55cca56/tests/unit/src/unit/TestReflect.hx 
// 
// t(expr) - expr should be true 
// f(expr) - expr should be false 

function testCompareMethods() { 
    var a = new MyClass(0); 
    var b = new MyClass(1); 
    t(Reflect.compareMethods(a.add,a.add)); 
    f(Reflect.compareMethods(a.add,b.add)); 
    f(Reflect.compareMethods(a.add,a.get)); 
    f(Reflect.compareMethods(a.add,null)); 
    f(Reflect.compareMethods(null, a.add)); 
    /* 
     Comparison between a method and a closure : 
     Not widely supported atm to justify officiel support 
     var fadd : Dynamic = Reflect.field(a, "add"); 
     var fget : Dynamic = Reflect.field(a, "get"); 
     t(Reflect.compareMethods(fadd, fadd)); 
     t(Reflect.compareMethods(a.add, fadd)); 
     t(Reflect.compareMethods(fadd, a.add)); 
     f(Reflect.compareMethods(fadd, fget)); 
     f(Reflect.compareMethods(fadd, a.get)); 
     f(Reflect.compareMethods(fadd, null)); 
    */ 
} 

Inoltre, possibile caso d'uso

class Test { 
    static function main() { 
     var a = new A(); 
     var i:I = a; 
     trace(Reflect.compareMethods(a.test, i.test)); //returns true 
    } 
} 

interface I 
{ 
    function test():Void; 
} 

class A implements I 
{ 
    public function new() {} 
    public function test() {} 
}