Параметры типа роли должны быть динамическими

Question

Я только начал использовать haxe(moving from AS3).

Я пытаюсь передать в массив, но это не работает, а именно, я получаю ошибку Cast type parameters must be Dynamic при попытке скомпилировать. Ниже приведен код, я использую:

var result: Array<String> = cast(["sometext"], Array<String>);   

    var arr: Array<Int> = new Array<Int>(); 
    arr.push(1); 
    var vect : Array<Int> = cast(arr, Array<Int>); 

    var arr1: Array<Int> = [1, 2 ,3]; 
    var vect1 : Array<Int> = cast(arr1, Array<Int>); 

    var arr2 = [1, 2 ,3]; 
    var vect2 : Array<Int> = cast(arr2, Array<Int>); 

Каждый из этих 4 слепков не компилировать и дает ту же ошибку «Cast параметры типа должны быть динамичными». Если я изменю параметр типа на Dynamic, он тоже не будет работать. Он терпит неудачу с другой ошибкой.

Может кто-нибудь объяснить, почему этот способ кастинга не работает и как я могу бросить в Массив?

Другие слепки:

var i: Int = 1; 
    var j: Int = cast(i, Int); 

    var str: String = "str"; 
    var str1: String = cast(str, String); 

    var instance: CastToArrayTest = new CastToArrayTest(); 
    var instance1: CastToArrayTest = cast(instance, CastToArrayTest); 

работать нормально.

Answer 1

Я думаю, что это, возможно, легче объяснить с какой-то пример кода:

class Test { 
    static function main() { 
     var a = ["foo", "bar"]; 
     $type(a); // Warning : Array<String> 

     // no need to cast or type simple assignments 
     var b = a; 
     $type(b); // Warning : Array<String> 

     // but lets define `x` as `Dynamic` (or something that we don't know what it is) 
     var x:Dynamic = ["foo", "bar"]; 
     $type(x); // Warning: Dynamic 

     // we can simply assign it to an `Array<Dynamic>` variable (but we don't get any runtime checks!) 
     var c:Array<Dynamic> = x; 
     $type(c); // Warning: Array<Dynamic> 

     // we can also simply assign it to an `Array<String>` variable (but we don't runtime checks either!!) 
     var d:Array<String> = x; 
     $type(d); // Warning: Array<String> 

     // (if we want runtime checks, we need to code them with the `Type` apis) 

     // now, let's say we want to do 
     //  var e:Array<String> = c; 
     // but that fails with `Type parameters are invariant`... 
     // we can instead use an unsafe cast 
     var e:Array<String> = cast c; 
     $type(e); // Warning: Array<String> 

     // type parameters are a compile time only feature 
     trace(showType(a), showType([1,2])); 
     trace(Std.is(a, Array), Std.is([1,2], Array)); 
     // safe casts only check the current object (not its children), so we need to use them with `Dynamic` parameters 
     var f = cast(x, Array<Dynamic>); 
     $type(f); // Warning: Array<Dynamic> 
     // however, due to variance, we can't assign a the safe cast result of type `Array<Dynamic` to a `Array<String>` variable without an unsafe cast... 
     // which makes sense: our safe cast only checks that the object is an array, but the array doesn't know its own type nor has the safe cast checked the types of the children 
    } 

    static function showType(v:Dynamic) 
    { 
     switch Type.typeof(v) { 
     case TClass(cl): 
      return Type.getClassName(cl); 
     case other: // TODO handle other types 
      return Std.string(other); 
     } 
    } 
} 

Вы можете играть с этим жить в Try Haxe #CCaD5.

---

Собираем по-другому, вот как ваши «литые» примеры, как правило, работать и выглядеть следующим образом:

var result: Array<String> = cast ["sometext"]; 

var arr: Array<Int> = new Array<Int>(); 
arr.push(1); 
var vect : Array<Int> = arr; 

var arr1: Array<Int> = [1, 2 ,3]; 
var vect1 = arr1; 

var arr2 = [1, 2 ,3]; 
var vect2 = arr2; 

var i: Int = 1; 
var j: Int = i; 
var k = j; 

var str: String = "str"; 
var str1: String = str; 
var str2 = str1; 

var instance: CastToArrayTest = new CastToArrayTest(); 
var instance1: CastToArrayTest = instance; 
var instance2 = instance1; 

Вы можете увидеть это вживую (с некоторой дополнительной информации) в Try Haxe #97ADc.