www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Pop quiz, what does this do?

reply Steven Schveighoffer <schveiguy gmail.com> writes:
The FieldNameTuple from std.traits returns a tuple of names of all the 
fields that are present on a type instance.

What about the result on things that can't have fields?

import std.traits;

interface I
{
    int foo();
}

pragma(msg, FieldNameTuple!I);

Without looking up the docs, or trying it, what do you think it does?

-Steve
Mar 03
next sibling parent reply Stefan Koch <uplink.coder googlemail.com> writes:
On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer 
wrote:
 The FieldNameTuple from std.traits returns a tuple of names of 
 all the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it 
 does?

 -Steve
My feeling is that it returns tuple("foo"). But based on the name that probably shouldn't happen.
Mar 03
parent reply Stefan Koch <uplink.coder googlemail.com> writes:
On Wednesday, 3 March 2021 at 16:31:53 UTC, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven 
 Schveighoffer wrote:
 The FieldNameTuple from std.traits returns a tuple of names of 
 all the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think 
 it does?

 -Steve
My feeling is that it returns tuple("foo"). But based on the name that probably shouldn't happen.
Huh ... it works as it should in this case. Pleasant surprise :)
Mar 03
next sibling parent Steven Schveighoffer <schveiguy gmail.com> writes:
On 3/3/21 11:33 AM, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:31:53 UTC, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer wrote:
 The FieldNameTuple from std.traits returns a tuple of names of all 
 the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it does?
My feeling is that it returns tuple("foo"). But based on the name that probably shouldn't happen.
Huh ... it works as it should in this case. Pleasant surprise :)
It works as designed. It's the design I question. For instance, code like: foreach(m; FieldNameTuple!T) // do something with __traits(getMember, T, m) will fail. Not because FieldNameTuple complains that it can't have field names, but because of what it's hard-coded to do. -Steve
Mar 03
prev sibling parent reply Simen =?UTF-8?B?S2rDpnLDpXM=?= <simen.kjaras gmail.com> writes:
On Wednesday, 3 March 2021 at 16:33:35 UTC, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:31:53 UTC, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven 
 Schveighoffer wrote:
 The FieldNameTuple from std.traits returns a tuple of names 
 of all the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think 
 it does?

 -Steve
My feeling is that it returns tuple("foo"). But based on the name that probably shouldn't happen.
Huh ... it works as it should in this case. Pleasant surprise :)
No it doesn't. Look again. -- Simen
Mar 03
parent Stefan Koch <uplink.coder googlemail.com> writes:
On Wednesday, 3 March 2021 at 17:17:52 UTC, Simen Kjærås wrote:
 On Wednesday, 3 March 2021 at 16:33:35 UTC, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:31:53 UTC, Stefan Koch wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven 
 Schveighoffer wrote:
 The FieldNameTuple from std.traits returns a tuple of names 
 of all the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think 
 it does?

 -Steve
My feeling is that it returns tuple("foo"). But based on the name that probably shouldn't happen.
Huh ... it works as it should in this case. Pleasant surprise :)
No it doesn't. Look again. -- Simen
:p I actually expected tuple("") :) Don't ask me why. Of course when trying to the result for anything that's bogus. But using phobos introspection templates always leads to pain, so it's a good thing to teach people not to do that :)
Mar 03
prev sibling next sibling parent reply Simen =?UTF-8?B?S2rDpnLDpXM=?= <simen.kjaras gmail.com> writes:
On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer 
wrote:
 The FieldNameTuple from std.traits returns a tuple of names of 
 all the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it 
 does?
I remember seeing that a couple years back (https://forum.dlang.org/post/hwrsxypruzeffreqxasa forum.dlang.org). It seems intentional, but also very, very weird. Accordion to the PR (https://github.com/dlang/phobos/pull/2561), it was for consistency. Consistency with what, however, is unclear. -- Simen
Mar 03
parent Steven Schveighoffer <schveiguy gmail.com> writes:
On 3/3/21 11:41 AM, Simen Kjærås wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer wrote:
 The FieldNameTuple from std.traits returns a tuple of names of all the 
 fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it does?
I remember seeing that a couple years back (https://forum.dlang.org/post/hwrsxypruzeffreqxasa forum.dlang.org). It seems intentional, but also very, very weird.
Oh snap! almost 2 years ago, I had the same exact WTF moment. Except this time, it is affecting code that I have to fix.
 Accordion to the PR (https://github.com/dlang/phobos/pull/2561), it was 
 for consistency. Consistency with what, however, is unclear.
Thanks for the link. I think it's consistently uninutitive... -Steve
Mar 03
prev sibling next sibling parent reply Max Haughton <maxhaton gmail.com> writes:
On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer 
wrote:
 The FieldNameTuple from std.traits returns a tuple of names of 
 all the fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it 
 does?

 -Steve
"" - difference between a field and a member I'm guessing
Mar 03
parent Steven Schveighoffer <schveiguy gmail.com> writes:
On 3/3/21 11:42 AM, Max Haughton wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer wrote:
 The FieldNameTuple from std.traits returns a tuple of names of all the 
 fields that are present on a type instance.

 What about the result on things that can't have fields?

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it does?

 -Steve
"" - difference between a field and a member I'm guessing
No, it's not. A member that's not a field doesn't normally produce anything in the tuple. Try this one: interface I { int foo(); int bar(); } -Steve
Mar 03
prev sibling next sibling parent reply Dukc <ajieskola gmail.com> writes:
On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer 
wrote:

 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it 
 does?
I'd think it either returns nothing, or the typeid and monitor fields (or whatever they are) that all classes are supposed to have.
Mar 03
parent Steven Schveighoffer <schveiguy gmail.com> writes:
On 3/3/21 11:52 AM, Dukc wrote:
 On Wednesday, 3 March 2021 at 16:06:48 UTC, Steven Schveighoffer wrote:
 
 import std.traits;

 interface I
 {
    int foo();
 }

 pragma(msg, FieldNameTuple!I);

 Without looking up the docs, or trying it, what do you think it does?
I'd think it either returns nothing, or the typeid and monitor fields (or whatever they are)  that all classes are supposed to have.
It does neither of those things. -Steve
Mar 03
prev sibling parent "H. S. Teoh" <hsteoh quickfur.ath.cx> writes:
On Wed, Mar 03, 2021 at 11:06:48AM -0500, Steven Schveighoffer via
Digitalmars-d wrote:
 The FieldNameTuple from std.traits returns a tuple of names of all the
 fields that are present on a type instance.
 
 What about the result on things that can't have fields?
 
 import std.traits;
 
 interface I
 {
    int foo();
 }
 
 pragma(msg, FieldNameTuple!I);
 
 Without looking up the docs, or trying it, what do you think it does?
[...] My guess was it should be an empty tuple. Boy was I surprised. :-( I dug through the git history and found the original PR: https://github.com/dlang/phobos/pull/2561 Somebody asked why an empty string instead of an empty tuple, and the submitter said he would change it, but then someone else said to keep consistency, and apparently it was subsequently overlooked or just left at an empty string. My gut feeling is, this should be changed to an empty tuple. It really makes no sense otherwise, and is a strange corner case like the kind deadalnix mentioned that will lead to pain down the road. T -- A mathematician is a device for turning coffee into theorems. -- P. Erdos
Mar 03