Tail Const (Was: I closed a very old bug!)

[Simen Kjærås]

On Wednesday, 17 January 2018 at 10:36:44 UTC, Jonathan M Davis 
wrote:
> D is quite useable without tail-const, but without it, ranges 
> and const can't be used together. The solution that most of us 
> have taken is basically to give up on const. Having tail-const 
> would be better, but implementing it without language support 
> is a royal pain and not the sort of thing that most of us are 
> going to bother with. It's just easier to give up on const. It 
> would be a _lot_ nicer if we could figure out how to cleanly 
> add tail-const to the language.

Sadly, constness doesn't propagate in a straightforward way - the 
equivalent const type for Foo!(int, int) could be Foo!(int, 
const(int)), Foo!(const(int), int), or Foo!(const(int), 
const(int)), and there's no way to specify this. At least in 
theory, it might even be that the const version is an entirely 
different template instantiation, so even something like `struct 
Foo(T, inout U)` might not be good enough. We might decide not to 
support anything as weird as different template overload sets, 
though.

If we look at what we already have, the basic building block is 
std.traits.Unqual. What's needed is a hook for those cases where 
Unqual!(const(R!T)) shouldn't simply be R!T. If Unqual tested for 
a member, e.g. "Unqual", and returned that type, that's important 
parts of the issue solved.

"Unqual" would probably be on the form 'alias Unqual(this T) = 
Foo!(CopyTypeQualifiers!(T, Args));'.

The big thing missing after amending Unqual like this, is 
implicit conversion. Currently, const(Foo!T) is generally not 
implicitly convertible to Foo!(const(T)). Since D templates are 
complex beasts, again there's not necessarily a straightforward 
way to do this. Alias this is some help, but trying to get that 
to work I ran into https://issues.dlang.org/show_bug.cgi?id=18260.

At any rate, this is a topic for a DIP.

--
   Simen