Haxe, differentiate anonymous function at runtime

I'm trying to differentiate anonymous functions like:

function() { trace("WOO"); }

from the other ones ('named'?) like

var _FUNC:Dynamic = function() { trace("WOO"); }

The reason I want to do that is because I can't compare between two anonymous functions, because they are two different ones.

To help me make things clearer, consider the following quick example.

var _TEST:Dynamic = function(开发者_JAVA技巧a:Dynamic):String {
  var _TESTA:Dynamic = function() { trace("WOO"); };
  var _TESTB:Dynamic = _FUNC;
  return (a == _TESTA) + ", " + (a == _TESTB);
}

If I run _TEST(_FUNC);, I'll get back "false, true". Even though they are the same function, they are NOT the same object.

Is there a way to compare those such that functions that they are the same if they perform the same task?

Is there a way to serialize functions? So that maybe I can compare the serialized representations and see if they share the same 'code'.

---

A few clarifications:

• The first two samples you have posted are virtually identical. The only difference is that you have assigned the second to a static var. You could have used a static function directly with the main difference that in that case the function is not changeable If you want to make it so you should add the dynamic modifier.

• Starting from the latest version you can have local named functions:

  static f() { function a() { trace("hi"); }; a() }
  

• To properly compare methods you should use Reflect.compareMethods(). Sometimes Haxe creates closures around functions and that can break equality.

• You can compare function references but not the function bodies. So the answer is no, you can't compare function that are generated in different statements but do the same thing.

• You cannot serialize functions.

• You can maybe find some platform specific way to deal with this situation or Macro may apply too (to create function signatures) but I think it is easier to redesign your code. Another option is to adopt a lib like hscript for those calls that need to be comparable and serializable.