Problem with immutables and Template typeof(this)

[Tobias Pankrath via Digitalmars-d-learn]

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