Question

我需要一个基于泛型的类，它只适用于两种基本类型。这些类型彼此不相关（未实现不相互扩展）。有什么办法吗？

Answer 1

同意其他评论和答案，在不知道您尝试实现的目的的情况下，很难知道接受两种不相关类型的重点是什么。

我能想到的几件事情：

1。如果您从不以特定于类型的方式使用对象（例如，您只将它序列化为JSON，这适用于任何类型），那么您可以使用抽象包装动态：

例如，请查看Andy Li's jQuery externs中的Either课程：

abstract Either<T1, T2>(Dynamic) from T1 from T2 to T1 to T2 {}

然后你可以打电话：

var arr:Array<Either<String,Int>>;
arr.push(0);
arr.push("hi");
var myInt = arr[0];
var myString:String = arr[1]; // you might need to use explicit type hints

这基本上是一个场景下的数组，但它只允许你使用String或Int。

2. 如果您正在构建自己的类，只需要接受一种或另一种类型的参数，您只需使用可选的函数参数：

function doSomething( ?myInt:Int, ?myString:String ) {
    if ( myInt!=null ) trace('Int!');
    else if ( myString!=null ) trace('String!');
}

3. 如果您想要 1 之类的内容，但键入更严格，则可以使用更高级的摘要。冒着自我推销的风险，我详细地写了a blog post这个技术，但我在这里粘贴了基本代码：

class Test {
    static function main(){
        stringOrInt( "hello" );
        stringOrInt( 10 );
    }
    static function stringOrInt( either:AcceptEither<String,Int> ) {
        switch either.type {
            case Left(str): trace("string: "+str);
            case Right(int): trace("int: "+int);
        }
    }
}

abstract AcceptEither<A,B> (Either<A,B>) {
    public inline function new( e:Either<A,B> ) this = e;
    public var value(get,never):Dynamic;
    public var type(get,never):Either<A,B>;

    inline function get_value() switch this { case Left(v) | Right(v): return v; }
    @:to inline function get_type() return this;
    @:from static function fromA( v:A ):AcceptEither<A,B> return new AcceptEither( Left(v) );
    @:from static function fromB( v:B ):AcceptEither<A,B> return new AcceptEither( Right(v) );
}

enum Either<A,B> {
    Left( v:A );
    Right( v:B );
}

你可以像var arr:Array<AcceptEither<String,Int>> = []一样使用任何泛型类。

Answer 2

您可以使用Map（haxe std lib）中使用的方法。 Here is the current source.

有没有办法限制某些类型的泛型？

2 个答案: