Thread overview | ||||||||
---|---|---|---|---|---|---|---|---|
|
August 04, 2019 Send/Receive bug in std.concurrency with immutable(ubyte[]) ? | ||||
---|---|---|---|---|
| ||||
import std.concurrency; import std.stdio; void testThread() { receive( (immutable(ubyte[]) data) => writeln("Got it!"), (Variant v) => writeln("Mismatch: ", v.type())); } void main() { immutable(ubyte[]) data = [1, 2, 3]; auto tid = spawn(&testThread); send(tid, data); } The output of this program is: Mismatch: immutable(ubyte)[] Why does calling send with data of type immutable(ubyte[]) get converted to immutable(byte)[] when it is called with std.concurrency's send() and receive(). Is this a bug? |
August 04, 2019 Re: Send/Receive bug in std.concurrency with immutable(ubyte[]) ? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Vijay Nayar | On Sunday, 4 August 2019 at 13:57:14 UTC, Vijay Nayar wrote: > import std.concurrency; > import std.stdio; > > void testThread() { > receive( > (immutable(ubyte[]) data) => writeln("Got it!"), > (Variant v) => writeln("Mismatch: ", v.type())); > } > > void main() { > immutable(ubyte[]) data = [1, 2, 3]; > auto tid = spawn(&testThread); > send(tid, data); > } > > The output of this program is: > Mismatch: immutable(ubyte)[] > > Why does calling send with data of type immutable(ubyte[]) get converted to immutable(byte)[] when it is called with std.concurrency's send() and receive(). Is this a bug? immutable(T[]) "decays" to immutable(T)[] when passed to a function (most of the time [1]): import std.stdio; void checkType(T)(T arg) { writeln(typeof(arg).stringof); } void main() { immutable(ubyte[]) a; checkType(a); // immutable(ubyte)[] } [1] https://issues.dlang.org/show_bug.cgi?id=18268 |
August 04, 2019 Re: Send/Receive bug in std.concurrency with immutable(ubyte[]) ? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Paul Backus | On Sunday, August 4, 2019 8:29:05 AM MDT Paul Backus via Digitalmars-d wrote:
> On Sunday, 4 August 2019 at 13:57:14 UTC, Vijay Nayar wrote:
> > import std.concurrency;
> > import std.stdio;
> >
> > void testThread() {
> >
> > receive(
> >
> > (immutable(ubyte[]) data) => writeln("Got it!"),
> > (Variant v) => writeln("Mismatch: ", v.type()));
> >
> > }
> >
> > void main() {
> >
> > immutable(ubyte[]) data = [1, 2, 3];
> > auto tid = spawn(&testThread);
> > send(tid, data);
> >
> > }
> >
> > The output of this program is:
> > Mismatch: immutable(ubyte)[]
> >
> > Why does calling send with data of type immutable(ubyte[]) get
> > converted to immutable(byte)[] when it is called with
> > std.concurrency's send() and receive(). Is this a bug?
>
> immutable(T[]) "decays" to immutable(T)[] when passed to a
> function (most of the time [1]):
>
> import std.stdio;
>
> void checkType(T)(T arg) { writeln(typeof(arg).stringof); }
>
> void main()
> {
> immutable(ubyte[]) a;
> checkType(a); // immutable(ubyte)[]
> }
>
> [1] https://issues.dlang.org/show_bug.cgi?id=18268
When you slice a const or immutable dynamic array, the type of the resulting dynamic array is tail-const or tail-immutable. When templates are implicitly instantiated with IFTI, and a dynamic array is passed in, the type is always inferred using the type of the slice of the dynamic array. That's completely consistent. You only get a fully const or immutable dynamic array with a template when the template is explicitly instantiated with that type.
However, based on the examples in that bug report, what happens with lambdas and function/delegate literals is not consistent - or at least, the reasons why the type inference uses the type of the slice in some cases and the type of the array being sliced in others isn't immediately clear.
- Jonathan M Davis
|
August 04, 2019 Re: Send/Receive bug in std.concurrency with immutable(ubyte[]) ? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan M Davis | On Sunday, 4 August 2019 at 15:19:49 UTC, Jonathan M Davis wrote:
> On Sunday, August 4, 2019 8:29:05 AM MDT Paul Backus via Digitalmars-d wrote:
>> On Sunday, 4 August 2019 at 13:57:14 UTC, Vijay Nayar wrote:
>> > import std.concurrency;
>> > import std.stdio;
>> >
>> > void testThread() {
>> >
>> > receive(
>> >
>> > (immutable(ubyte[]) data) => writeln("Got it!"),
>> > (Variant v) => writeln("Mismatch: ", v.type()));
>> >
>> > }
>> >
>> > void main() {
>> >
>> > immutable(ubyte[]) data = [1, 2, 3];
>> > auto tid = spawn(&testThread);
>> > send(tid, data);
>> >
>> > }
>> >
>> > The output of this program is:
>> > Mismatch: immutable(ubyte)[]
>> >
>> > Why does calling send with data of type immutable(ubyte[]) get
>> > converted to immutable(byte)[] when it is called with
>> > std.concurrency's send() and receive(). Is this a bug?
>>
>> immutable(T[]) "decays" to immutable(T)[] when passed to a
>> function (most of the time [1]):
>>
>> import std.stdio;
>>
>> void checkType(T)(T arg) { writeln(typeof(arg).stringof); }
>>
>> void main()
>> {
>> immutable(ubyte[]) a;
>> checkType(a); // immutable(ubyte)[]
>> }
>>
>> [1] https://issues.dlang.org/show_bug.cgi?id=18268
>
> When you slice a const or immutable dynamic array, the type of the resulting dynamic array is tail-const or tail-immutable. When templates are implicitly instantiated with IFTI, and a dynamic array is passed in, the type is always inferred using the type of the slice of the dynamic array. That's completely consistent. You only get a fully const or immutable dynamic array with a template when the template is explicitly instantiated with that type.
>
> However, based on the examples in that bug report, what happens with lambdas and function/delegate literals is not consistent - or at least, the reasons why the type inference uses the type of the slice in some cases and the type of the array being sliced in others isn't immediately clear.
>
> - Jonathan M Davis
Sorry, sir, this day your participation in this forum is very limited. Is it due to work load? I really want to know. You can reach me personally with this mail: greatsam4sure@gmail.com
Sorry sir, is just that I don't know how else to reach you.
|
August 06, 2019 Re: Send/Receive bug in std.concurrency with immutable(ubyte[]) ? | ||||
---|---|---|---|---|
| ||||
Posted in reply to GreatSam4sure | On Sunday, August 4, 2019 12:30:37 PM MDT GreatSam4sure via Digitalmars-d wrote: > Sorry, sir, this day your participation in this forum is very limited. Is it due to work load? I really want to know. You can reach me personally with this mail: greatsam4sure@gmail.com > > Sorry sir, is just that I don't know how else to reach you. I still participate, but I don't want it to suck up my time as it sometimes has. A combination of some health issues and trying to focus on work have reduced how much time I've been spending on D in general outside of work, though I do need to figure out how to spend some more time contributing. If you wish to contact me about something, the about page on my website provides my e-mail address: http://jmdavisprog.com/about.html - Jonathan M Davis |
August 06, 2019 Re: Send/Receive bug in std.concurrency with immutable(ubyte[]) ? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jonathan M Davis | On Tuesday, 6 August 2019 at 10:27:49 UTC, Jonathan M Davis wrote:
> On Sunday, August 4, 2019 12:30:37 PM MDT GreatSam4sure via Digitalmars-d wrote:
>> [...]
>
> I still participate, but I don't want it to suck up my time as it sometimes has. A combination of some health issues and trying to focus on work have reduced how much time I've been spending on D in general outside of work, though I do need to figure out how to spend some more time contributing.
>
> If you wish to contact me about something, the about page on my website provides my e-mail address:
>
> http://jmdavisprog.com/about.html
>
> - Jonathan M Davis
Thanks, it is cool to hear from you
|
Copyright © 1999-2021 by the D Language Foundation