why won't byPair work with a const AA?

Steven Schveighoffer via Digitalmars-d-learn digitalmars-d-learn at puremagic.com
Thu Aug 3 10:26:16 PDT 2017


On 8/3/17 4:30 AM, Olivier FAURE wrote:

> I understand the general concept you're describing, but what exactly are 
> tail modifiers? It's the first time I see this name, and my google-fu 
> gives me nothing.

tail modifiers are modifiers that only apply to the "tail" of the type.

For example const(int)* is applying const to the "tail" of the int 
pointer, that is, the int that it points at. It's not applying to the 
actual pointer itself (we call that the "head").

Another way to look at it is that when you copy a variable you always 
make a copy of the head, and you don't make a copy of the tail. For this 
reason, the fully-modified and tail-modified types are implicitly 
castable, and this is the important property we need to duplicate.

A tail-modified struct would be something like this:

struct S
{
    int * x;
}

const(S) s;

This looks like this:

struct ConstS
{
    const(int *) x;
}

A tail-const S would look like this:

struct TailConstS
{
    const(int)* x;
}

That is, everything the struct points at remains const, but the actual 
data of the struct is now mutable.

Note that TailConstS and ConstS can implicitly convert.

This is how arrays work. An array T[] is really:

struct Array
{
    size_t length;
    T* ptr;
}

A tail-const array const(T)[] is really:

struct TailConstArray
{
    size_t length; // mutable
    const(T)* ptr; // mutable, but points at const data
}

This property of implicit casting is what's needed to fully realize 
custom ranges and const together. The way to get it is to define 
tail-modifier syntax for all types, not just arrays and pointers.

-Steve


More information about the Digitalmars-d-learn mailing list