Something like following can substitute dynamic array:
struct da(T){
T* ptr;
int len, capacity;
T opIndex(int i){}
int length(){ return len;}
void length(int len){ // do allocation}
this(int i){ //allocate memory for ptr }
this(){ // do nothing}
da!(T) opCat(T* a){ //do concat }
da!(T) opCat_r(T* a){ //do concat }
da!(T) opCat(T c){ //do concat }
da!(T) opCat_r(T c){ //do concat }
opAssign(T* p) {}
opAssign(da!(T) da) {}
da!(T) opMul(int i) {}
da!(T) opMul(da!(T) i) {} // some dot product ?
da!(T) opDiv(da!(T) i) {}
}
auto myda = da!(int)(3)
auto p = da!(int)();
p = myda~3;
The cons/pros of this proposal:
Cons:
ungly syntax da!(int)(3) is really worse than int[3];
slow down the compiling process
Pros:
We can extend dynamic array without D2 feature of alias This
Also Tuple!(int, float) is accused as ugly
I believe the metatype programming system here not yet fully exploited.
The template matching is powerful, but the syntax is aweful.
how about the following beautify of da!(int)(3) and tuple!(int,float)
type(T) // overload all types
{
opIndex(int v)
{
type = da!(T)(v) // we directly meta program the type system
}
opIndex(U)
{
// associate array, assume we created some associate array struct
template named Aa
type = Aa!(U, T)
}
opCat(U)
{
type = Tuple!(T,U);
}
}
then we can do :
int[3] => type(int) opIndex(int v) then further resolve the type to be
da!(int)(3)
int~float => type(int) opCat(float) , therefore further resolve the type
to be Tuple!(int, float)
I think tuple of int~float is quite acceptable
With this directly metaprogramming, we can solve series of issues all
together.
We can define a matrix by int^int or float^float
Imagine:
int^int mat= new int^int(3,4);
int[4] p;
auto v= mat*p; // we can do a lot compile time check in the compiletime
type syntax meta programming
We can define function curry as:
f^g h;
h(3) will eventually become f(g(3));
We can do a lot more new things!! :)
