overiding mutable methods in immutable classes

[anonymous via Digitalmars-d-learn]

On Saturday, 22 November 2014 at 17:40:42 UTC, Eric wrote:
> Yes, but this is what I really want:
>
> class X(T : immutable Object)
> {
>     private T x;
>     this(T x) pure { this.x = x; }
> }
>
> class Y
> {
>     private int x;
>     this(int x) pure { this.x = x; }
> }
>
> void main()
> {
>     immutable(Y) y = new immutable Y(5);
>     X!(Y) x = new X!(Y)(y);
> }
>
> // test.d(16): Error: template instance X!(Y) does not
> // match template declaration X(T : immutable(Object))

I'm not sure what you're getting at. That is, I don't see which
parts of the code you want to be as they are.

For example, this works:

class X(T /* optionally, restrict T to class types:*/ /*: const
Object*/)
{
       private T x;
       this(T x) pure { this.x = x; }
}
/* Maybe add a convenience construction function: */
X!T newX(T)(T x) {return new X!T(x);}

class Y
{
       private int x;
       this(int x) pure { this.x = x; }
}

void main()
{
       immutable(Y) y = new immutable Y(5);
       X!(immutable Y) x = new X!(immutable Y)(y);
       auto x2 = newX(y); /* same as above, but less wordy */
}

But I'm not sure if maybe I changed to much about it.

My point is, that I think it's generally a good idea to be
flexible when possible, and not make (im)mutability demands
unless actually necessary.

You may know the following, but I feel like there may be some
confusion about it: Note that immutable(Y) is a different type
from just Y. And declaring Y as `immutable class Y` wouldn't
change a thing about that, as the "immutable" there only affects
the members of Y. Objects of the bare type Y would still be
(head) mutable.