Array Multi Type

Test.hx

class Test {
    static function main() {
        var ar = new MyArray<Int>([1, 2, 5]);
        trace(ar);
        ar.length = 5;
        trace(ar);
        ar.length = 2;
        trace(ar);
        
        var ar2 = new MyArray<Float>([1.1, 2.2, 5.5]);
        trace(ar2);
        ar2.length = 5;
        trace(ar2);
        ar2.length = 2;
        trace(ar2);
        
        var ar3 = new MyArray<String>(["Hello", "world", "!"]);
        trace(ar3);
        ar3.length = 5;
        trace(ar3);
        ar3.length = 2;
        trace(ar3);
        
        var ar4 = new MyArray<Dynamic>();
        trace(ar4);
        ar4.length = 5;
        trace(ar4);
        ar4.length = 2;
        trace(ar4);
    }
}

@:multiType(K)
abstract MyArray<K>(IMyArray<K>) {
    public function new (?array:Array<K>);
    public var length (get, set) : Int;
    inline function get_length () : Int return this.get_data_length();
    inline function set_length (value:Int) : Int return this.set_data_length(value);
    @:arrayAccess public inline function get (index:Int) : K return this.get(index);
    @:arrayAccess public inline function set (index:Int, value:K) : K return this.set(index, value);
    public inline function toString () : String return this.toString();
    @:to static inline function toMyIntArray (t:IMyArray<Int>, ?a:Array<Int>) : MyIntArray {
		var c = new MyIntArray();
		if (a != null) c.data = a;
		return c;
	}
    @:from static inline function fromMyIntArray (array:MyIntArray) : MyArray<Int> {
        return cast array;
    }
    @:to static inline function toMyFloatArray (t:IMyArray<Float>, ?a:Array<Float>) : MyFloatArray {
		var c = new MyFloatArray();
		if (a != null) c.data = a;
		return c;
	}
    @:from static inline function fromMyFloatArray (array:MyFloatArray) : MyArray<Float> {
        return cast array;
    }
    @:to static inline function toMyStringArray (t:IMyArray<String>, ?a:Array<String>) : MyStringArray {
		var c = new MyStringArray();
		if (a != null) c.data = a;
		return c;
	}
    @:from static inline function fromMyStringArray (array:MyStringArray) : MyArray<String> {
        return cast array;
    }
    @:to static inline function toMyDynamicArray (t:IMyArray<Dynamic>, ?a:Array<Dynamic>) : MyDynamicArray {
		var c = new MyDynamicArray();
		if (a != null) c.data = a;
		return c;
	}
    @:from static inline function fromMyDynamicArray (array:MyDynamicArray) : MyArray<Dynamic> {
        return cast array;
    }
}

interface IMyArray<K> {
    public function get_data_length () : Int;
    public function set_data_length (value:Int) : Int;
    public function get (index:Int) : K;
    public function set (index:Int, value:K) : K;
    public function toString () : String;
}

class MyBaseArray<K> {
    @:allow(MyArray) private var data : Array<K>;
    public function new () {
        data = new Array<K>();
    }
    public inline function get_data_length () : Int {
        return data.length;
    }
    public function get (index:Int) : K {
        if (index < get_data_length()) {
            return data[index];
        } else {
            throw "Index outside of MyArray";
        }
    }
    public function set (index:Int, value:K) : K {
        if (index < get_data_length()) {
            return data[index] = value;
        } else {
            throw "Index outside of MyArray";
        }
    }
    public inline function toString () : String {
        return data.toString();
    }
    public function set_data_length (value:Int) : Int {
        if (value > get_data_length()) {
			var v = defaultValue();
			var l = get_data_length();
			var i = value - get_data_length() - 1;
			while (i >= 0) {
                 data[l + i] = v;
                 i--;
            }
        } else if (value < get_data_length()) {
            data.splice(value, get_data_length() - value);
        }
        
        return get_data_length();
    }
    public function defaultValue () : K {
		throw "Not implemented";
	}
}

class MyIntArray implements IMyArray<Int> extends MyBaseArray<Int> {    
    public override function defaultValue () : Int {
		return 0;
	}
}

class MyFloatArray implements IMyArray<Float> extends MyBaseArray<Float> {    
    public override function defaultValue () : Float {
		return 0.0;
	}
}
    
class MyStringArray implements IMyArray<String> extends MyBaseArray<String> {    
    public override function defaultValue () : String {
		return "";
	}
}
    
class MyDynamicArray implements IMyArray<String> extends MyBaseArray<Dynamic> {    
    public override function defaultValue () : Dynamic {
		return null;
	}
}