Generics 在Haxe中强制转换为泛型类型

更新问题：

我对劳伦斯·泰勒的答案做了一些挖掘和研究。我就快到了，但它似乎不适用于递归包装。下面是一个更新的可运行代码片段，显示了问题所在（这次使用我的类，因为我不想重新定义所有内容）

具体地说，请注意，

{t:3}

（正确地）第一次绑定到一个衡平法，但是当

{t:{t:3}

（同样正确地）绑定到一个衡平法时，嵌套的

{t:3}

绑定到一个非衡平法。同一对象

t1

和

t2

第一次绑定到

equired

，但第二次绑定到

nonequired

，这怎么可能呢

---

问题v1:

我正在通过Haxe进行深入研究，并已达到一个简化为以下内容的程度：

interface SelfReferringInterface<X> {
    public function doStuff(x : X) : Void;
}

class A {
    private var x : Int;
    public function new(x : Int){this.x = x;}

    public function toString() {return Std.string(x);}
}

class B implements SelfReferringInterface<B> {
    private var x : Int;

    public function new (x : Int){this.x = x;}

    public function doStuff(b : B) {
        trace(this + " and " + b);
    }

    public function toString() { return Std.string(x);}
}

我想在

GenericClass

中添加一个方法，如果它是

T

的一个实现，则

selfrefereringinterface

将调用doStuff，否则会有一些其他默认行为：

class GenericClass<T> {
    private var t : T;
    public function new(t : T) {this.t = t;}

    public function doStuffOrTrace(t2 : T) {
         //if t instanceof SelfReferringClass, call t.doStuff(t2)
         //otherwise call trace(t) and ignore t2
    }
}

class泛型类{
私有变量t:t；
公共函数new（t:t）{this.t=t；}
公共功能竞赛（t2:T）{
//如果selfrefereringclass的t instanceof，则调用t.doStuff（t2）
//否则调用trace（t）并忽略t2
}
}

这样，以下试验方法可执行以下操作

class Test {
    static function main() {
        new GenericClass<A>(new A(3)).doStuffOrTrace(new A(4));//Expect 3
        new GenericClass<B>(new B(1)).doStuffOrTrace(new B(2));//Expect 1 and 2
    }
}

类测试{
静态函数main（）{
新的GenericClass（新的A（3））.doStuffOrTrace（新的A（4））；//预期3
新的GenericClass（新的B（1））.doStuffOrTrace（新的B（2））；//除1和2之外
}
}

是否尽可能实现

doStuffOrTrace（..）

？我可以控制所有的类，但我试图避免改变

A

和

B

，以使之成为可能。我可以根据需要添加到

SelfReferringInterface

或

GenericClass

。想法

---

---

我做了一些挖掘，似乎（由于协方差的使用），我宁愿

selfrefereringinterface

是一个typedef而不是一个接口。我仍然坚持实现

doStuffOrTrace（..）

，但这可能会开辟新的途径？

最好编写一个同时包含这两种情况的枚举，将其封装在摘要中，并为每种情况编写@from函数，并将其用作doStuffOrTrace的输入

在正常使用中，调用函数将导致调用正确的抽象构造函数，然后您可以在内部使用开关来区分

*编辑

@:来自HasInterface的静态公共函数（v:SelfReferringInterface）：HasInterfaceOrno{
返回THasInterface（v）；
}
enum Hasideornott{
THasInterface（v：自引用接口）；
THasNotInterface（v：动态）；
}

---

请参阅运行代码，您可以使用Std.is实现doStuffOrTrace以确定t的类型，并将其强制转换到SelfReferringInterface：

public function doStuffOrTrace(t2 : T) {
    if(Std.is(t, SelfReferringInterface)){
        var castedT = cast(t, SelfReferringInterface<Dynamic>);
        castedT.doStuff(t2);
    }else{
        trace(t);
    }
}

doStuffOrTrace公共功能（t2:T）{
if（标准is（t，自参考接口））{
var castedT=cast（t，自引用接口）；
杜斯塔夫城堡（t2）；
}否则{
微量元素（t）；
}
}

问题是您从未明确使用toString方法，因此编译器（dce）会将其剥离，跟踪（t）将输出“[object]”

您可以通过向方法添加@：keep元数据来防止这种情况，但因为 不能修改A和B，可以使用

-dce no

或

-dce std

编译器标志禁用dce

---

下面是try.haxe代码片段：

我可以试一试。。能否添加一个有效使用@：from语法的示例？这对我来说太新鲜了！我用过你的代码，90%都能用，但递归调用遇到了一些麻烦。请看我更新的问题我要尝试的一件事是显式键入wrap的输出，关于泛型类型的类型解析存在一些歧义。考虑到抽象构造函数应该被隐式调用，您实际上不必首先显式调用wrap，并且可以完全避免可等式的问题。

@:from static public function fromHasInterface<T>(v:SelfReferringInterface<T>):HasInterfaceOrNot<T>{
  return THasInterface(v);
}
enum HasInterfaceOrNotT<T>{
  THasInterface(v:SelfReferringInterface<T>);
  THasNotInterface(v:Dynamic);
}

public function doStuffOrTrace(t2 : T) {
    if(Std.is(t, SelfReferringInterface)){
        var castedT = cast(t, SelfReferringInterface<Dynamic>);
        castedT.doStuff(t2);
    }else{
        trace(t);
    }
}