Maybe someone knows why it doesn't work?

import std.concurrency;
import std.stdio: write, writeln, writef, writefln;
import std.variant : Variant;
import std.process : thisThreadID;

alias Buffer = immutable(ubyte)[];

void pros2(string name)
    {
     receive(

            (immutable(Buffer[]) h){
                writeln(h);
                ownerTid.send(123);
            }
     );
 }
void main()
{

    Buffer[] t ;
    t ~= cast(Buffer)"sdfsdfsdf";
    t ~= cast(Buffer)"sdfsdfsdf";
    immutable(Buffer[]) ti = cast(immutable)t;


    auto tid2 = spawn(&pros2, "hello");
    send(tid2, ti);
    receive(
       (int h){writeln(h);}
    );
 }

On Thursday, 20 January 2022 at 09:38:55 UTC, Alexey wrote:

Buffer[] t ;
t ~= cast(Buffer)"sdfsdfsdf";
t ~= cast(Buffer)"sdfsdfsdf";
immutable(Buffer[]) ti = cast(immutable)t;

This is undefined behavior.

Since ti isn't really immutable.

You can still modify the original buffer (t).

You should use const instead of immutable and, that goes for your functions too.

They should receive const and not immutable.

Summary:

Mutable means: Anyone and anything can modify it.
Immutable means: Nobody will modify it, not here and not anywhere else. Initialization is only allowed, but not pointing to anything that has mutable references.
Const means: I promise not to modify it, but another mutable reference might.

In your example t is a mutable reference, where as ti is an immutable reference.

That's illegal and constitutes as UB (Undefined behavior)

It would have been legal if you either used const or if you made an immutable duplication of t with ex. t.idup.

On Thursday, 20 January 2022 at 10:18:03 UTC, bauss wrote:

Buffer[] t ;
t ~= cast(Buffer)"sdfsdfsdf";
t ~= cast(Buffer)"sdfsdfsdf";
immutable(Buffer[]) ti = cast(immutable)t;

Oh wait, I just noticed Buffer is an alias to an immutable array.

Ignore what I just said...

On Thursday, 20 January 2022 at 10:19:37 UTC, bauss wrote:

Buffer[] t ;
t ~= cast(Buffer)"sdfsdfsdf";
t ~= cast(Buffer)"sdfsdfsdf";
immutable(Buffer[]) ti = cast(immutable)t;

I'm too fast again, well don't ignore entirely what I said, since you still modify an immutable reference by appending to t, I believe.

I'm not 100% sure about this one, but I'm 99% sure.

On Thursday, 20 January 2022 at 10:21:23 UTC, bauss wrote:

problem: we cant receive Buffer[], solution is to make some wrapper, but its interesting why we cant without

On Thursday, 20 January 2022 at 09:38:55 UTC, Alexey wrote:

import std.concurrency;
import std.stdio: write, writeln, writef, writefln;
import std.variant : Variant;
import std.process : thisThreadID;

alias Buffer = immutable(ubyte)[];

void pros2(string name)
    {
     receive(

            (immutable(Buffer[]) h){
                writeln(h);
                ownerTid.send(123);
            }
     );
 }
void main()
{

    Buffer[] t ;
    t ~= cast(Buffer)"sdfsdfsdf";
    t ~= cast(Buffer)"sdfsdfsdf";
    immutable(Buffer[]) ti = cast(immutable)t;


    auto tid2 = spawn(&pros2, "hello");
    send(tid2, ti);
    receive(
       (int h){writeln(h);}
    );
 }

It's a Phobos bug.

import std.variant;
void main() {
    alias A = immutable(ubyte)[];
    auto a = Variant(immutable(A[]).init);
    assert(a.convertsTo!(immutable(A[])));
}

File a bug report, please?

On Thursday, 20 January 2022 at 11:24:18 UTC, FeepingCreature wrote:

import std.variant;
void main() {
    alias A = immutable(ubyte)[];
    auto a = Variant(immutable(A[]).init);
    assert(a.convertsTo!(immutable(A[])));
}

On 1/20/22 5:21 AM, bauss wrote:

Note that casting from mutable to immutable is actually defined as long as you don't modify the data after that (as seen here). It's actually technically defined to cast to mutable from immutable as long as you don't modify the mutable data (this can be a requirement if you are calling a C function for example that takes a mutable reference that you know won't modify the data for that call).

Appending to immutable array data is not considered a modification, because within the context of the language, an append is like tacking on unallocated data to the end of the array.

-Steve