• Nick Sabalausky (13/13) Jan 15 2012 Is there a way to get the name of an enum value at compile-time?
• Jonathan M Davis (3/20) Jan 15 2012 to!string(Foo.hello)
• Nick Sabalausky (33/56) Jan 15 2012 Nope. That was the first thing I tried.
• Timon Gehr (2/5) Jan 15 2012 enum x = to!string(Foo.hello);
• Nick Sabalausky (3/9) Jan 15 2012 Goddamnnit, what the fuck is wrong with me? Yes that works :)
• Timon Gehr (3/13) Jan 15 2012 I suspect a better error message would have prevented this.
• Philippe Sigaud (16/19) Jan 15 2012 In that case, to!(Origin, Target) could be extended to deal with
• Peter Alexander (4/24) Jan 15 2012 The compiler should be able to give you a better error message. It

"Nick Sabalausky" <a a.a> writes:

Is there a way to get the name of an enum value at compile-time?

For instance:

import std.stdio;
enum Foo { hello }
void main()
{
    writeln(Foo.hello);
}

That prints "hello". But what I need is to get "hello" into a string at 
compile-time.

Of course, I could just manually write a ctfe-able "fooToString()", or 
implement something like std.typecons.defineEnum (which appears to be 
deprecated now). But I'm wondering if I'm overlooking a better solution.

Jonathan M Davis <jmdavisProg gmx.com> writes:

On Sunday, January 15, 2012 03:53:09 Nick Sabalausky wrote:
 Is there a way to get the name of an enum value at compile-time?
 
 For instance:
 
 import std.stdio;
 enum Foo { hello }
 void main()
 {
     writeln(Foo.hello);
 }
 
 That prints "hello". But what I need is to get "hello" into a string at
 compile-time.
 
 Of course, I could just manually write a ctfe-able "fooToString()", or
 implement something like std.typecons.defineEnum (which appears to be
 deprecated now). But I'm wondering if I'm overlooking a better solution.

to!string(Foo.hello)

- Jonathan M Davis

"Nick Sabalausky" <a a.a> writes:

"Jonathan M Davis" <jmdavisProg gmx.com> wrote in message 
news:mailman.388.1326617938.16222.digitalmars-d-learn puremagic.com...
 On Sunday, January 15, 2012 03:53:09 Nick Sabalausky wrote:
 Is there a way to get the name of an enum value at compile-time?

 For instance:

 import std.stdio;
 enum Foo { hello }
 void main()
 {
     writeln(Foo.hello);
 }

 That prints "hello". But what I need is to get "hello" into a string at
 compile-time.

 Of course, I could just manually write a ctfe-able "fooToString()", or
 implement something like std.typecons.defineEnum (which appears to be
 deprecated now). But I'm wondering if I'm overlooking a better solution.

 to!string(Foo.hello)

Nope. That was the first thing I tried.

With 2.057:

type testCTEnumToString.d

import std.conv;
enum Foo { hello }
enum x = to!string();

dmd testCTEnumToString.d -c

phobos\std\conv.d(237): Error: template std.conv.toImpl(T,S) if 
(isImplicitlyConvertible!(S,T)) does not match any function template 
declaration
phobos\std\conv.d(237): Error: template std.conv.toImpl(T,S) if 
(isImplicitlyConvertible!(S,T)) cannot deduce template function from 
argument types !(string)()
phobos\std\conv.d(237): Error: template instance toImpl!(string) errors 
instantiating template
testCTEnumToString.d(3):        called from here: to()

Doesn't work at runtime, either:

type testRTEnumToString.d

import std.conv;
enum Foo { hello }
void main()
{
        auto x = to!string();
}

dmd testRTEnumToString.d -c

phobos\std\conv.d(237): Error: template std.conv.toImpl(T,S) if 
(isImplicitlyConvertible!(S,T)) does not match any function template 
declaration
phobos\std\conv.d(237): Error: template std.conv.toImpl(T,S) if 
(isImplicitlyConvertible!(S,T)) cannot deduce template function from 
argument types !(string)()
phobos\std\conv.d(237): Error: template instance toImpl!(string) errors 
instantiating template
testRTEnumToString.d(5): Error: template instance std.conv.to!(string).to!() 
error instantiating

Timon Gehr <timon.gehr gmx.ch> writes:

On 01/15/2012 09:34 PM, Nick Sabalausky wrote:
 import std.conv;
 enum Foo { hello }
 enum x = to!string();

enum x = to!string(Foo.hello);

"Nick Sabalausky" <a a.a> writes:

"Timon Gehr" <timon.gehr gmx.ch> wrote in message 
news:jevefv$2je6$1 digitalmars.com...
 On 01/15/2012 09:34 PM, Nick Sabalausky wrote:
 import std.conv;
 enum Foo { hello }
 enum x = to!string();

 enum x = to!string(Foo.hello);

Goddamnnit, what the fuck is wrong with me? Yes that works :)

Timon Gehr <timon.gehr gmx.ch> writes:

On 01/15/2012 10:02 PM, Nick Sabalausky wrote:
 "Timon Gehr"<timon.gehr gmx.ch>  wrote in message
 news:jevefv$2je6$1 digitalmars.com...
 On 01/15/2012 09:34 PM, Nick Sabalausky wrote:
 import std.conv;
 enum Foo { hello }
 enum x = to!string();

 enum x = to!string(Foo.hello);

 Goddamnnit, what the fuck is wrong with me? Yes that works :)

I suspect a better error message would have prevented this.
DMD still has some potential of improvement in that area. =)

Philippe Sigaud <philippe.sigaud gmail.com> writes:

On Sun, Jan 15, 2012 at 22:19, Timon Gehr <timon.gehr gmx.ch> wrote:

Nick:
 Goddamnnit, what the fuck is wrong with me? Yes that works :)

 I suspect a better error message would have prevented this.
 DMD still has some potential of improvement in that area. =)

In that case, to!(Origin, Target) could be extended to deal with
to!(Origin, <empty there>).
It's been a long time since I last looked at std.conv.to, but maybe:

template to(T)
{
    T to(A...)(A args)
    {
        static if (A.length)
            return toImpl!T(args);
        else
            static assert(false, "Trying to use to!("~T.stringof~")
with no argument. What were you trying to do?");
    }
}

Peter Alexander <peter.alexander.au gmail.com> writes:

On 15/01/12 10:29 PM, Philippe Sigaud wrote:
 On Sun, Jan 15, 2012 at 22:19, Timon Gehr<timon.gehr gmx.ch>  wrote:

 Nick:
 Goddamnnit, what the fuck is wrong with me? Yes that works :)

 I suspect a better error message would have prevented this.
 DMD still has some potential of improvement in that area. =)

 In that case, to!(Origin, Target) could be extended to deal with
 to!(Origin,<empty there>).
 It's been a long time since I last looked at std.conv.to, but maybe:

 template to(T)
 {
      T to(A...)(A args)
      {
          static if (A.length)
              return toImpl!T(args);
          else
              static assert(false, "Trying to use to!("~T.stringof~")
 with no argument. What were you trying to do?");
      }
 }

The compiler should be able to give you a better error message. It 
shouldn't be the responsibility of the programmer to provide sensible 
error messages when you call a function with the wrong number of arguments.