Template-style polymorphism in table structure

[data pulverizer via Digitalmars-d-learn]

On Sunday, 4 September 2016 at 14:49:30 UTC, Lodovico Giaretta 
wrote:
> On Sunday, 4 September 2016 at 14:24:12 UTC, data pulverizer 
> wrote:
>> On Sunday, 4 September 2016 at 14:20:24 UTC, data pulverizer 
>> wrote:
>> @Lodovico Giaretta BTW what do you mean that my code is not 
>> very D style? Please expand on this ...
>
> The constructors can be less. In fact, a typesafe variadic ctor 
> also works for the single element case and for the array case. 
> But you already recognized that.
>
> Instead of reinventing the wheel for your GenericVector!T, you 
> could use an `alias this` to directly inherit all operation on 
> the underlying array, without having to reimplement them (like 
> your append method).
>
> Your getCol(i) could become getCol!T(i) and return an instance 
> of GenericVector!T directly, after checking that the required 
> column has in fact that type:
>
> GenericVector!T getCol!T(size_t i)
> {
>     if(typeid(cols[i]) == typeid(GenericVector!T))
>         return cast(GenericVector!T)cols[i];
>     else
>         // assert(0) or throw exception
> }
>
> Another solution: if you don't need to dynamically change the 
> type of the columns you can have the addColumn function create 
> a new type. I show you with Tuples because it's easier:
>
> Tuple!(T,U) append(U, T...)(Tuple!T tup, U col)
> {
>     return Tuple!(T,U)(tup.expand, col);
> }
>
> Tuple!int t1;
> Tuple!(int, float) t2 = t1.append(2.0);
> Tuple!(int, float, char) t3 = t2.append('c');

Thank you for the very useful suggestions, I shall take these 
forward. On the suggestion of creating Tuple-like tables, I 
already tried that but found as you said that once the table is 
created, adding/removing columns is essentially creating a 
different data type, which needs a new variable name each time.

I am building a table type I hope will be used for data 
manipulation for data science and statistics applications, so I 
require a data structure that can allow adding and removing 
columns of various types as well as a data structure that can 
cope with any type that hasn't been planned for, which is why I 
selected this polymorphic template approach. It is more flexible 
than other data structures I have seen in dynamic programming 
languages R's data frame and Python pandas. Even Scala's Spark 
dataframes rely on wrapping everything in Any and the user still 
has to write a special data structure for each new type. The only 
thing that is similar to this approach is Julia's DataFrame but 
Julia - though a very good programming language has limitations.

I feel as if I am constantly scratching the surface of what D can 
do, but I have recently managed to get more time on my hands and 
it looks as if that will continue into the future which will mean 
more focusing on D, improving my generic programming skills and 
hopefully creating some useful artifacts. Perhaps I need to read 
Andrei's Modern C++ Design book for a better way to think about 
generics.