如何在 Haxe (haxe3) 中编写通用比较函数

Question

我正在尝试在 Haxe3 中为模板类型 A 编写通用比较函数（如 c strcmp），假设此模板类型具有小于或等于运算符“

我在 Haxe3 文档 (http://haxe.org/manual/haxe3/features) 中看到，如果您想假设模板类型具有新功能，您可以执行类似的工作：

@:generic static function foo<T:{function new(s:String):Void;}>(t:T) {
    trace(Type.typeof(t)); // TClass([class String]) / TClass([class Template])
    return new T("foo");
}

所以，我用“le”函数尝试了同样的技术：

class Main {
    @:generic static public function compare_<A:{function le(y:A):Bool;}>(x:A,y:A): Int {
        if (x.le(y) && y.le(x)) return 0;
        else if (x.le(y)) return -1;
        else return 1;
    }


    static function main() {
        var a:MyInt  = new MyInt(1);
        var b:MyInt  = new MyInt(2);
        trace(compare_(a,b));
    }
}

class MyInt {
    var data:Int;
    public function new(i:Int) {this.data = i; }
    public function le(y:MyInt){return data <= y.data;}
}

上面的 compare_ 函数适用于任何具有先决条件“le”函数的类型。上面的代码按预期返回 -1。但显然，为 Int 创建一个新类，只提供le 函数是相当不方便的。我的问题是，有没有办法重写 compare_ 函数，使其适用于定义了“

以下是我尝试过的：

@:generic static public function compare_<A:{@:op(X <= Y) function le(x:A,y:A):Bool;}>(x:A,y:A): Int {
     if (x <= y && y <= x) return 0;
     else if (x <= y) return -1;
     else return 1;
 }

当然不能编译。 Haxe 抱怨“le”未定义。

我正在寻找不涉及宏的轻量级解决方案，因为我打算在其他语言中重用 haxe 生成的代码而不依赖于 Boot。或scuts。动态也不适合我的目的，因为根本没有类型安全。

提前致谢。

---

更新： 我做了一些额外的阅读，并认为我可以使用using 和callback 机制将le 方法注入到我想要的每种类型中。请参阅我关于 "import and using may not appear after a type declaration" -- the haxe using magic 的相关问题。

Answer 1

处理问题的两种安全方法：

1。宏

class Main {
    macro static public function compare_(a, b)
        return macro @:pos(a.pos) { 
            var a = $a, 
            b = $b; 
            if (a <= b) 
                if (b <= a) 0;
                else -1;
            else 1;
        }  

    static function main() {
        var a = 1,
            b = 2;
        trace(compare_(a,b));
    }
}

2。摘要

abstract Comparator<T>({f: T->Int }) {
    public function new(f) 
        this = { f: f };

    public function compare(other:T):Int
        return this.f(other);

    @:from static function fromInt(i:Int)
        return simple(i);

    @:from static function fromFloat(f:Float)
        return simple(f);

    @:from static function fromString(s:String)
        return simple(s);

    @:from static function fromComparable<A>(o:{ function compareTo(other:A):Int; })
        return new Comparator(o.compareTo);

    static function simple<X>(o:X):Comparator<X>
        return new Comparator(Reflect.compare.bind(o));
}

class Main {
    static public function compare_<A>(a:Comparable<A>, b:A)
        return a.compare(b);

    static function main() {
        function comparable(value)
             return { 
                 value: value, 
                 compareTo: function(other) 
                     return Reflect.compare(value, other.value) 
             }          
        trace(compare_(1,2));
        trace(compare_(1.5,2.5));
        trace(compare_('foo','bar'));
        trace(compare_(comparable(1),comparable(2))); 
    }
}