• ParticlePeter (21/21) Apr 28 2014 DMD tells me "Error: variable m cannot be read at compile time",
• Andrej Mitrovic (26/28) Apr 28 2014 Because 'static foreach' is not an explicit feature yet, so it
• ParticlePeter (8/36) Apr 28 2014 Thank you very much, it works. I never came so far to see those
• Andrej Mitrovic via Digitalmars-d-learn (6/10) Apr 28 2014 If you need to store the tuple as an array to some variable, then you
• Philippe Sigaud via Digitalmars-d-learn (17/21) Apr 28 2014 I guess a common use case is to create an array with [__traits(...)],
• Dicebot (4/31) Apr 28 2014 You can do the same iterating directly over allMembers list, why
• Philippe Sigaud via Digitalmars-d-learn (4/6) Apr 28 2014 Hmm, indeed. One advantage would be to get a range, and thus the power

"ParticlePeter" <ParticlePeter gmx.de> writes:

DMD tells me "Error: variable m cannot be read at compile time", 
but why ?

[code]
struct MyStruct {
	float float_value = 0.0f ;
	ubyte ubyte_value = 2 ;
}

enum members = [ __traits( allMembers , MyStruct ) ] ;

foreach( m ; members )  {
	mixin( "writeln( " ~ m ~ " , \" : \" , ( MyStruct." ~ m ~ 
".offsetof ) ;" ) ;
}
[\code]

I also tried ref m and foreach( i ; 0..members.length ) with 
m[i]. A simple writeln( m or m[i] ) always  worked.
I read the limitation of "String Mixins and Compile Time Function 
Execution" here: http://dlang.org/function.html#interpretation
But it doesn't make sense to me as members are enum values and 
known at compile time.

What am I doing wrong, and how could it be done ?

Regards, ParticlePeter

"Andrej Mitrovic" <andrej.mitrovich gmail.com> writes:

On Monday, 28 April 2014 at 13:52:52 UTC, ParticlePeter wrote:
 DMD tells me "Error: variable m cannot be read at compile 
 time", but why ?

Because 'static foreach' is not an explicit feature yet, so it 
depends on the context. When you wrap the trait via:

[__traits(allMembers, MyStruct)]

You're creating an array, and foreach will *not* by default 
attempt to become a static foreach, even if the array is known at 
compile-time. If you remove the parentheses it will work. You've 
had a few bugs in the mixin code though, anyway here's the 
working sample:

-----
import std.stdio;

struct MyStruct
{
     float float_value = 0.0f;
     ubyte ubyte_value = 2;
}

enum members = __traits(allMembers, MyStruct);

void main()
{
     foreach (m; members)
     {
         mixin("writeln( `" ~ m ~ "` , \" : \" , ( MyStruct." ~ m 
~ ".offsetof ) );");
     }
}
-----

"ParticlePeter" <ParticlePeter gmx.de> writes:

On Monday, 28 April 2014 at 13:57:56 UTC, Andrej Mitrovic wrote:
 On Monday, 28 April 2014 at 13:52:52 UTC, ParticlePeter wrote:
 DMD tells me "Error: variable m cannot be read at compile 
 time", but why ?

 Because 'static foreach' is not an explicit feature yet, so it 
 depends on the context. When you wrap the trait via:

 [__traits(allMembers, MyStruct)]

 You're creating an array, and foreach will *not* by default 
 attempt to become a static foreach, even if the array is known 
 at compile-time. If you remove the parentheses it will work. 
 You've had a few bugs in the mixin code though, anyway here's 
 the working sample:

 -----
 import std.stdio;

 struct MyStruct
 {
     float float_value = 0.0f;
     ubyte ubyte_value = 2;
 }

 enum members = __traits(allMembers, MyStruct);

 void main()
 {
     foreach (m; members)
     {
         mixin("writeln( `" ~ m ~ "` , \" : \" , ( MyStruct." ~ 
 m ~ ".offsetof ) );");
     }
 }
 -----

Thank you very much, it works. I never came so far to see those 
mixin errors at all :-)
I found the code with parenthesis in the dlang __traits docs and 
also Philippe Sigauds "D Templates", and I haven't seen any other 
example which works without them. So, when to use which syntax ( 
for which purpose ) ? Is this clarified somewhere ?
Regards, ParticlePeter

Andrej Mitrovic via Digitalmars-d-learn writes:

On 4/28/14, ParticlePeter via Digitalmars-d-learn
<digitalmars-d-learn puremagic.com> wrote:
 I found the code with parenthesis in the dlang __traits docs and
 also Philippe Sigauds "D Templates", and I haven't seen any other
 example which works without them. So, when to use which syntax (
 for which purpose ) ?

If you need to store the tuple as an array to some variable, then you
would use that syntax. It all depends on what you're trying to do from
the call site. Ultimately it won't matter much once we finally get a
proper 'static foreach' feature in D.

Philippe Sigaud via Digitalmars-d-learn writes:

On Mon, Apr 28, 2014 at 5:45 PM, Andrej Mitrovic via
Digitalmars-d-learn <digitalmars-d-learn puremagic.com> wrote:

 If you need to store the tuple as an array to some variable, then you
 would use that syntax. It all depends on what you're trying to do from
 the call site. Ultimately it won't matter much once we finally get a
 proper 'static foreach' feature in D.

I guess a common use case is to create an array  with [__traits(...)],
and use it inside a function, iterating on it and creating a string
with the elements. The string is then mixed in with a CTFE call.

string makeCode(...) {
    enum members = [ __traits(allMembers, MyStruct) ];

    string result;
    foreach (m; members)
    {
        result ~= "writeln( `" ~ m ~ "` , \" : \" , ( MyStruct." ~ m ~
".offsetof ) );");
    }
    return result;
}

mixin(makeCode());

I don't know what I used it for in the tutorial, though :-)

"Dicebot" <public dicebot.lv> writes:

On Monday, 28 April 2014 at 17:40:54 UTC, Philippe Sigaud via 
Digitalmars-d-learn wrote:
 On Mon, Apr 28, 2014 at 5:45 PM, Andrej Mitrovic via
 Digitalmars-d-learn <digitalmars-d-learn puremagic.com> wrote:

 If you need to store the tuple as an array to some variable, 
 then you
 would use that syntax. It all depends on what you're trying to 
 do from
 the call site. Ultimately it won't matter much once we finally 
 get a
 proper 'static foreach' feature in D.

 I guess a common use case is to create an array  with 
 [__traits(...)],
 and use it inside a function, iterating on it and creating a 
 string
 with the elements. The string is then mixed in with a CTFE call.

 string makeCode(...) {
     enum members = [ __traits(allMembers, MyStruct) ];

     string result;
     foreach (m; members)
     {
         result ~= "writeln( `" ~ m ~ "` , \" : \" , ( 
 MyStruct." ~ m ~
 ".offsetof ) );");
     }
     return result;
 }

 mixin(makeCode());

 I don't know what I used it for in the tutorial, though :-)

You can do the same iterating directly over allMembers list, why 
would you prefer array here?

Philippe Sigaud via Digitalmars-d-learn writes:

On Mon, Apr 28, 2014 at 8:20 PM, Dicebot via Digitalmars-d-learn
<digitalmars-d-learn puremagic.com> wrote:

 You can do the same iterating directly over allMembers list, why would you
 prefer array here?

Hmm, indeed. One advantage would be to get a range, and thus the power
and filtering, mapping and co.