On Wednesday, 1 September 2021 at 12:32:36 UTC, Steven Schveighoffer wrote:

As long as the type author does not use unsafe casts, the compiler will prevent them from getting the conversions wrong.

On Wednesday, 1 September 2021 at 11:04:41 UTC, Steven Schveighoffer wrote:

template Vector(T) if (isConst!T) { alias Vector = tailconst(.Vector!(Unqual!T)); }

If the type is unrelated, then you are back to the heuristic problem.

On Wednesday, 1 September 2021 at 11:57:01 UTC, Paul Backus wrote:

It still wouldn't work when manipulating things by reference.

In fact, the litmus test for a solution to that problem should be: can we reproduce the behavior of builtin types such as T* or T[] with it?

On Wednesday, 1 September 2021 at 12:52:47 UTC, deadalnix wrote:

It doesn't work when manipulating built-in types by reference either:

void manipulate(ref const(int)[] arr) {}

void main()
{
    const(int[]) arr;
    manipulate(arr);
    // Error: cannot pass argument `arr` of type `const(int[])`
    // to parameter `ref const(int)[] arr`
}

On Tuesday, 31 August 2021 at 17:21:02 UTC, deadalnix wrote:

Try this template parameter:

import std.traits : CopyConstness, isMutable;


void main(){
    {
        Vector!int a;
        Vector!(const int) b = a;
        const Vector!int c = b;
    }
    {
        Vector!int a;
        Vector!(const int) b;
        b = a;
    	
    }
}


struct Vector(T){
    alias ElementType = T;

    this(U, this This)(ref Vector!U rhs)
    if(!is(U == T) && isCopyable!(This, typeof(rhs))){
    	//impl
    }

    this(U, this This)(Vector!U rhs)
    if(isCopyable!(typeof(rhs), This)){
    	//impl
    }

	///TODO copy ctors...

    void opAssign(U, this This)(auto ref Vector!U rhs)
    if(isCopyable!(typeof(rhs), This) && isMutable!This){
    	//impl
    }
}

private enum bool isCopyable(From, To) = is(
	CopyConstness!(From, From.ElementType[]) : CopyConstness!(To, To.ElementType[])
);

On Wednesday, 1 September 2021 at 13:22:46 UTC, Paul Backus wrote:

void manipulate(ref const(int)[] arr) {}

void main()
{
    const(int[]) arr;
    manipulate(arr);
    // Error: cannot pass argument `arr` of type `const(int[])`
    // to parameter `ref const(int)[] arr`
}

No you right, this is not what I meant (but this is def what I wrote).

I meant that int[][] or int[]* turtle the qualifier down.

On Wednesday, 1 September 2021 at 18:23:06 UTC, deadalnix wrote:

Are you sure?

void manipulate(const(int)[][] arr) {}

void main()
{
    const(int[][]) arr;
    manipulate(arr);
    // Error: cannot pass argument `arr` of type `const(int[][])`
    // to parameter `const(int)[][] arr`
}

On Wednesday, 1 September 2021 at 18:32:29 UTC, Paul Backus wrote:

void manipulate(const(int)[][] arr) {}

void main()
{
    const(int[][]) arr;
    manipulate(arr);
    // Error: cannot pass argument `arr` of type `const(int[][])`
    // to parameter `const(int)[][] arr`
}

Yes, const(int[][]) is effectively const(const(const(int)[])[]).

In the same way, you want const(Vector!int[]) to be const(const(Vector!(const(int))[]).

Which means that you should be able to convert implicitly a reference to a Vector!int into a reference to a Vector!(const(int)).

In your example, you remove const qualifiers, so it obviously doesn't work. But it work in the other direction, when you add them. It won't for a collection even with an implicit cast operation, as what is really desired is some kind of reinterpret_cast.

On Wednesday, 1 September 2021 at 02:08:40 UTC, max haughton wrote:

Great point. Game engines extensively use such data layouts when storing vertex data. That's reason for Jai wanting a builtin SoA type. Jai has interestingly since made that a library feature.

On Wednesday, 1 September 2021 at 00:52:04 UTC, deadalnix wrote:

In what ways was it a disaster? Because most strings are small enough to benefit from the small string optimization?