Template error on compiling ...

[Stanislav Blinov]

On Friday, 28 February 2014 at 23:16:48 UTC, Robin wrote:
> Hiho,
>
> just for you: the whole code! =)
> http://dpaste.dzfl.pl/cd1537571a4d
>
> The idea is that I have matrix instances and so-called 
> ElementalOperations which are able to operate on matrices to 
> solve certain algorithms object oriented without nasty loops 
> and so on.

I'm going to repeat the advice from your thread about matrices: 
don't use upper case in module names. See 
http://dlang.org/module.html#ModuleDeclaration.

"delete" keyword will eventually go away, you're better off not 
using it.

Now to a suggestion: how about going up a type so you don't have 
to carry around the (T = double) and Matrix!T code dependencies? 
The tests below are simplified and clumped together, but should 
be enough for an illustration.

struct Matrix(T = double) { /* blah */ }

/// Tests if type M is a Matrix
enum bool isSomeMatrix(M) = is(M == Matrix!T, T);

/// Gets element type from a Matrix type
alias MatrixElement(M : Matrix!T, T) = T;

abstract class ElementalOperation(M) if (isSomeMatrix!M) { /* 
blah */ }

unittest {
     import std.typetuple;

     alias types = TypeTuple!(byte,short,int,long,float,double);
     foreach(T; types) {
         // don't accept scalars
         static assert(!isSomeMatrix!T);
         static assert(!is(MatrixElement!T));
         static assert(!is(ElementalOperation!T));
         // accept matrices
         static assert(isSomeMatrix!(Matrix!T));
         static assert(is(MatrixElement!(Matrix!T) == T));
         static assert(is(ElementalOperation!(Matrix!T)));
     }
}

This way all ElementalOperation's method signatures will 
transform from void foo(Matrix!T m) into void foo(M m), and the 
MatrixElement template will help in cases when you do need to get 
to underlying type.

> This had worked perfectly in my java implementation so far.

Well, D is not Java ;) As Ali mentioned, Matrix is not a type, 
Matrix!T is.