Suggestions to simplify the use of flash.Vectors?
Joshua Granick
You can't use a normal cast...
var vertices = cast ([1, 2, 3, 4], Vector<Int>);
...because the type parameter has to be dynamic.
You can't use a generic cast...
var vertices:Vector<Int> = cast [1, 2, 3, 4];
... because these are separate types at runtime in Flash.
You can use Vector.ofArray...
var vertices = Vector.ofArray ([1, 2, 3, 4]);
...but now you can't use it with other NME targets.
NME uses a typedef to make nme.Vector<T> the same as Array<T>
You can't extend Array<T>...
class Vector<T> extends Array<T>
...because basic types (like Array) can't be extended
You can't create a new data type...
class Vector<T> implements ArrayAccess<T>
...because ArrayAccess<T> won't actually be supported on the target
platform for the new type
You can't add a "using" mix-in...
class VectorHelper {
static function ofArray (v:Vector<T>, a:Array<T>):Vector<T> {
return a;
}
}
...because this would work on vector instances, not the static Vector class
So how do we cleanly implement an API that requires the Vector type?
It would be wonderful to have a nice solution that doesn't require
conditional code, or some kind of VectorUtils class
Dominic Graefen
Heinz Hölzer
How about:
class VectorHelper {
public static inline function ofArray (v:Class<Vector<T>>,
a:Array<T>):Vector<T> {
return cast a;
Joshua Granick
That was almost it. This works:
typedef Vector<T> = Array<T>;
class VectorHelper
{
public static inline function ofArray<T>(v:Class<Vector<Dynamic>>,
array:Array<T>):Vector<T>
{
return array;
}
}
This really helps.
Is there a way to implement this kind of functionality without requiring
"using nme.Vector"?
It would be great if this were added automatically when you imported the
nme.Vector class
Heinz Hölzer
Maybe it should be added to the issues list as a feature request ;)
However, maybe you can use another nice hacky feature which acts a little bit like haskell newtypes:
@:native("Array") // it gets compiled as an Array<T>, but acts as a different type
extern class Vector<T> {
public static inline function fromArray<T>(a:Array<T>):Vector<T> {
return cast a;
}
inline function unbox<T>():Array<T> {
return cast this;
}
public inline function push<T>(elem:T):Void {
this.unbox().push(elem);
}
}
usage:
var vec = Vector.fromArray([1,2,3]);
vec.push(4);
Simon Krajewski
> Is there a way to implement this kind of functionality without
> requiring "using nme.Vector"?
>
> It would be great if this were added automatically when you imported
> the nme.Vector class
I would actually reverse that and have "using" imply "import".
Simon
Heinz Hölzer
I prefer a distinction between them, but some sugar like:
import using MyType;
would be nice.
Simon Krajewski
>
> I prefer a distinction between them, but some sugar like:
>
> import using MyType;
>
> would be nice.
That'd work for me as well, but unlike the direct implication this would
require a parser change. I'm not sure if the implication has a drawback
which would justify that. Either way is fine with me though.
Simon
Hugh
I was thinking it might be good to have a generic "bucket" nme helper
class for compatibility reasons.
You could put vector in there, but also inject routines to help with
problems of RGBA on neko without the thirty-second bit.
ie, add BitmapData.create that take (rgb:Int, a:Int).
so you would just "import nme.Helpers" or "nme.Compat"
I also can't see where you would "use" a class without "importing" it
- so might be a good shorthand.
Hugh
On Mar 24, 6:26 am, "Joshua Granick" <bulkm...@joshuagranick.com>
wrote:
Nicolas Cannasse
> What's the reason that haXe Array<T> doesn't map to Vector<T> with a
> flash target?
> The instance APIs?
There is a difference between the two in the native APIs and many other
places. For instance String.split returns an Array, while other API
methods uses Vectors. So we can't compile everything to either Array or
Vector.
BTW the AVM2 support for Vectors is not very good : they don't bring
that much speed improvement over Arrays and this they are not real generics.
Best,
Nicolas
Juraj Kirchheim
Just a slight enhancement:
@:native("Array") extern class Vector<T> implements
ArrayAccess<T> { ... }
The only drawback here is, that at runtime you have no way of figuring
out whether something was created as an Array or a Vector, but I think
that's ok.
Regards,
Juraj