An issue I have is non-mutable expressions without indirections not converting to mutable. I talked about this before and mentioned Unqual at DConf 2022 to explain how it solves this.

The problem happens in template code:

void main() {
  const i = 42;  // const, so foo's T will be const below
  foo(i);
}

void foo(T)(T value) {
  T result;
  ++result;  // Compilation error; but should it work?
}

I feel like it should work because 'result' is a local int.

But I am aware that we can't deduce T to be 'int' because we would be losing that qualifier and further template deductions would be wrong. :/

Anyway... That's one thing that bugs me occasionally and causes bugs like the following one, which I think is caused by a missing Unqual:

  https://issues.dlang.org/show_bug.cgi?id=23319

At least, there is a moral here at least for myself: Don't forget to test your templates with const, etc.

Ali

```d
void main() {
	auto foo = const Foo("whatever");
	bar(foo);
}

struct Foo {
	char[] data;
}

void bar(T)(T value) {
	T thing = value;
	thing.data[0] = 'a';
}
```

Do you want this to error at compile time or at runtime due to writing to read only memory?

On 9/2/22 12:05, rikki cattermole wrote:

> struct Foo {
>      char[] data;
> }

> Do you want this to error at compile time or at runtime due to writing
> to read only memory?

Fair enough but that type has an indirection. I "feel" it should work for fundamental types, etc. without indirections but as I said, I understand it will ruin template type deduction as well as function overloading which I forgot to mention.

This thread is here to remind us to test our templates for const, etc. :)

Ali

On 03/09/2022 7:19 AM, Ali Çehreli wrote:
> Fair enough but that type has an indirection. I "feel" it should work for fundamental types, etc. without indirections but as I said, I understand it will ruin template type deduction as well as function overloading which I forgot to mention.

Yeah that's the problem isn't it, its exceptions in the type system that you have to add to get it to work for basic types only. For other types like slices, pointers, structs and classes it gets dangerous.