I just wanted to share a brief discussion on a PR last night, because it's something that's always bugged me, and there is a change in 2.111 that tightens the rules for declaring auto ref such that the keywords must appear next to eachother.

In the PR there was a piece of code that went `const auto ref T`, and I suggested changing to `auto ref const T` as convention at least.

The reason I perceive is that this is valid syntax: auto ref const(CowArray) rhs
This is not: const(auto ref CowArray) nhs

For me, it's a conceptual flow thing:
const auto ref T goes: type stuff (const) -> storage class stuff (auto ref) -> type stuff (T)
auto ref const T goes: storage class stuff (auto ref) -> type stuff (const T)

It feels crude to interleave type stuff and storage class stuff in an arbitrary way.

The distinction feels more compelling when you consider that parens may appear after type constructors (const(T)), and so in those cases, the code MUST be written with the const immediately preceding the type, forcing the storage class to the left.

Since it's invalid to put storage class stuff on the end (actual type must be on the end), then I would mandate that storage class stuff should go at the start, not randomly in the middle somewhere, ie: storage_class type_constructor actual_type

If it were up to me, I would mandate this in the spec, but failing that, at least proliferate this by general policy; I think this helps non-D coders to osmose this complexity without a detailed conversation... and for everyone else, the code just reads more consistently.

I see a surprising number of people writing `const ref T`, and I suspect that people are writing it holding the same kind of conceptual confusion that a lot of new users have expressed to me. As I see it, the fact people tend to write this at all is clear evidence that we shouldn't allow it!


Similarly, allowing attributes on functions should likewise appear after the function prototype:

struct S {
  const(T) method();
  const T method(); // not the same; synonym for `T method() const`
}
This kind of confusion is just totally unnecessary. Any non-expert reader would assume they are the same. There's no value in inviting this confusion.