Cast type parameters must be Dynamic - casting

Question

I just started using haxe(moving from AS3).
I'm trying to cast to Array, but it doesn't work, namely I get Cast type parameters must be Dynamic error when I try to compile. Below is the code I use:
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>);
Each of these 4 casts doesn't compile and gives the same error "Cast type parameters must be Dynamic". If I change the type parameter to Dynamic it won't work either. It fails with a different error.
Could someone explain why this way of casting is not working and how I can cast to Array?
Other casts:
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);
Work just fine.

Answer 1

I think it's perhaps easier to explain with some sample code:
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);
}
}
}
You can play with this live at Try Haxe #CCaD5.
Putting in another way, here's how your "cast" examples would usually work and look like:
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;
You can see this live (with some additional info) at Try Haxe #97ADc.