|Posted by Steven Schveighoffer|
in reply to H. S. Teoh
Posted in reply to H. S. Teoh
On 4/1/21 5:59 PM, H. S. Teoh wrote:
> Now, when you append a string to a const(char), the compiler has to
> promote `string` to `const(char)` first, so that the operands of ~
> have the same type. And obviously, the result of concatenating two
> const(char) must be const(char), since you don't know if one of them
> may have mutable aliases somewhere else. So the result must likewise be
But it's not.
auto z = x ~ y;
pragma(msg, typeof(z)); // char
This is what's confusing me. The compiler somehow knows it can do this implicit cast, but doesn't know that the result is unique. It should be obvious.
> One may argue that appending in general will reallocate, and once
> reallocated it will be unique, and there safe to implicitly convert to
> immutable. However, in general we cannot guarantee this, e.g., one of
> the strings could be empty and not reallocate at runtime, so it may
> continue to be aliased by some mutable reference somewhere else. So the
> result must be typed as const(char), along with the restriction that
> it cannot implicitly convert to immutable.
a ~ b will always allocate new memory, it's in the spec.