Problem with immutables and Template typeof(this)

[Ali Çehreli via Digitalmars-d-learn]

On 12/28/2014 02:07 PM, AuoroP via Digitalmars-d-learn wrote:

 > I have been trying to figure templates out...

Although the question has already been answered, here is a solution that 
combines most of the suggestions that have already been made. It does 
not need any kind of casting:

/* Eponymous template syntax is lighter */
struct ExampleTemplate(T)
{
     T value;

     this(T value)
     {
         this.value = value;
     }

     /* 1) As a shorthand, the name of the template is the same
      *    thing as this specific instantiation of it. For
      *    example, if the template is instantiated with "int",
      *    then ExampleTemplate alone means
      *    ExampleTemplate!int.
      *
      * 2) opAdd is marked 'const' so that it can work on
      *    mutable, const, and immutable objects.
      *
      * 3) The parameter is by-copy so that it can take rvalues as well.
      */
     ExampleTemplate opAdd(const(ExampleTemplate) that) const
     {
         return ExampleTemplate(this.value + that.value);

         /* Alternatively:

            auto result = ExampleTemplate(this.value + that.value);
            return result;
         */
     }
}

void main()
{
     /* New alias syntax makes more sense */
     alias Example = ExampleTemplate!int;

     immutable immutableEx = Example(1);
     Example ex = Example(1);
     Example ex2 = immutableEx + ex + immutableEx;
}

Ali