On Sunday, 28 December 2014 at 22:07:31 UTC, AuoroP via
Digitalmars-d-learn wrote:
I have been trying to figure templates out...
template ExampleTemplate(T)
{
struct ExampleTemplate
{
T value;
// constructor
auto this(T value)
{
this.value = value;
return this;
}
Constructor should not have a return value.
// opAdd
typeof(this) opAdd(typeof(this) that) // immutable
{
typeof(this) result;
result.value = this.value + that.value;
return result;
}
}
}
alias ExampleTemplate!int Example;
immutable immutableEx = Example(1);
Example ex = Example(1);
Example ex2 = immutableEx + ex;
I get this error with mutbale opAdd:
example.d(27): Error: mutable method
example.ExampleTemplate!int.ExampleTemplate.opAdd is not
callable using a immutable object
This is because you can only call member functions that are
marked with immutable, if your instance is immutable.
pragma(msg, typeof(this)) will print the type of this at compile
time.
I get this error with immutable opAdd
-------~-------+-------~-------=-------~-------+-------~-------
example.d(18): Error: cannot modify immutable expression
result.value
example.d(27): Error: template instance
example.ExampleTemplate!int error instantiating
This is because typeof(this) is immutable.
I get that typeof(this) is immutable ExampleTemplate!int.
I can't find any way to cast immutable away because
typeof(this) is the only way I know to get the type.
Well, the type is ExampleTemplate. No reason not to write it
directly. If you cannot for whatever reason I currently do not
see: cast to Unqual!(typeof(this)).
See http://dlang.org/phobos/std_traits.html
