Abstract generic dynamic static extension question 🤣

1

Hej !

Do you like my title ? So do I :rofl:

This naturally works : Try Haxe !

using Test.Dynamics;
class Dynamics{
	public static function ifNull<T>( expr : T, expr2 : T ) : T {
		return expr != null ? expr : expr2;
	}
}
class Test {
  static function main() {
    var o	: String = null;
    trace( o.ifNull( "foo" ) );
  }
}

This doesn’t. It compiles fine but at run-time it throws an exception because Haxe doesn’t “do” static extensions to Dynamic : Try Haxe !

using Test.Dynamics;
class Dynamics{
	public static function ifNull<T>( expr : T, expr2 : T ) : T {
		return expr != null ? expr : expr2;
	}
}
class Test {
  static function main() {
    var o	: Dynamic = null;
    trace( o.ifNull( "foo" ) );
  }
}

But this one works at run-time : Try Haxe !

using Test.Dynamics;
abstract Dynamics<T>(T) from T to T{
	public static function ifNull<T>( expr : Dynamics<T>, expr2 : Dynamics<T> ) : Dynamics<T> {
		return expr != null ? expr : expr2;
	}
}
class Test {
  static function main() {
    var o	: Dynamics<Dynamic> = null;
    trace( o.ifNull( "foo" ) );
  }
}

I just wanted to know if it is the right way to do, if someone can advice me please ?
And if is there any difference with that, any pro/cons (which also works on runtime) ? : Try Haxe !

using Test.Dynamics;
class Dynamics{
	public static function ifNull( expr : Dynamic, expr2 : Dynamic ) :Dynamic {
		return expr != null ? expr : expr2;
	}
}
class Test {
  static function main() {
    var o	: Dynamic = null;
    trace( o.ifNull( "foo" ) );
  }
}

Thanks !