如何在Haxe中编写通用比较函数(haxe3) [英] how to write a generic compare function in Haxe (haxe3)
问题描述
我在Haxe3文档中看到( http:/ /haxe.org/manual/haxe3/features ),你可以做一个类似的工作,如果你想假设模板类型具有新功能:
<$ (t:T){
trace(Type.typeof(t,t)){code> @:通用静态函数foo< T:{function new(s:String):Void;}& )); // TClass([class String])/ TClass([class Template])
return new T(foo);
$ / code>
因此,我尝试了使用le函数的相同技巧: p>
class Main {
@:泛型静态公共函数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返回1;
$ b静态函数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_函数以使其适用于定义了< =运算符的任何模板类型(Int,Float,带有重载运算符的其他类型)?
以下是我试过的内容:
@:generic (x:A,y:A):Bool;}>(x:A,y:A):Int {$ b $如果(x <= y&& y <= x)则返回0;
else if(x <= y)返回-1;
else返回1;
}
哪些当然不会编译。 Haxe抱怨说le是未定义的。
我正在寻找不涉及宏的轻量级解决方案,因为我打算在没有依赖的情况下重新使用haxe生成的其他语言代码在启动。或者scuts。动态对我来说也不好,因为根本没有类型安全。
预先感谢。
< hr>
更新:
我做了一些额外的阅读,并认为我可以注入 le
方法使用和
callback
机制,使用来实现我想要的每种类型。请参阅我的相关问题,该。
两种处理问题的安全方式:
1。宏
class Main {
static 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。摘要
抽象比较器< T>({f:T-> Int}){
public function new f)
this = {f:f};
public function compare(other:T):Int
return this.f(other);
@:从静态函数fromInt(i:Int)
return simple(i);
:从静态函数fromFloat(f:Float)
return simple(f);
@:从静态函数fromString(s:String)
返回简单(s);
@从静态函数fromComparable< A>(o:{function compareTo(other:A):Int;})
return new Comparator(o.compareTo);
静态函数简单< X>(o:X):比较器< X>
返回新的比较器(Reflect.compare.bind(o));
$ b class main {
static public function compare_< A>(a:Comparable< A> ;, b:A)
return a.compare(b) ;
静态函数main(){
函数可比较(值)
返回{
值:值,
compareTo:函数(其他)
返回Reflect.compare(value,other.value)
}
trace(compare_(1,2));
trace(compare_(1.5,2.5));
trace(比较_('foo','bar'));
trace(比较_(可比较(1),可比较(2)));
}
}
I am trying to write a generic compare function (like the c strcmp) in Haxe3 for a template type A, assuming that this template type has a less-than-or-equal-to operator "<=".
I saw in the Haxe3 documentation (http://haxe.org/manual/haxe3/features) that you can do a similar job if you want to assume that a template type has the new function:
@: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");
}
So, I tried the same technique with a "le" function:
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;}
}
The compare_ function above works fine for any type with the prerequisite "le" function. The above code returns -1 as expected. But it is rather inconvenient, obviously, to create a new class for Int, just to provide the le
function. My question is, is there a way to re-write the compare_ function to make it work for any template type (Int,Float, other types with overloaded operators) with a "<=" operator defined?
The following is what I have tried:
@: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;
}
which of course does not compile. Haxe complains that "le" is undefined.
I am looking for lightweight solutions without involving macros, as I intend to re-use the haxe generated code in other languages without dependance on Boot. or scuts. Dynamic is also not good for my purposes as there is no type-safety at all.
Thanks in advance.
Update:
I did some additional reading, and figured I might be able to inject an le
method the hard way into every type I want, using the using
and callback
mechanism. Please see my related question on that "import and using may not appear after a type declaration" -- the haxe using magic.
Two type safe ways to deal with the problem:
1. Macros
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. Abstracts
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)));
}
}
这篇关于如何在Haxe中编写通用比较函数(haxe3)的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!