In the past the argument from Walter against something like opImplicitCast has always been that users would get confused about random things happening if they had freedom to do any implicit cast they could think of.

The solution to this would be only to allow the implicit conversions discussed above. So instead of some general opImplicitCast it might be better described as opImplicitConstCast.

> Similarly, allow `immutable type!T` to convert to `type!(immutable T)`

That isn't always safe:

struct S(T)
{
    int* p;
}

void main()
{
    auto s = S!(immutable int)();
    immutable si = S!int();
    s = si; // currently an error
    *s.p = 4;
    assert(*si.p == 0); // fails
}