• Unwise (8/8) May 01 2014 In the following example from the documentation, are strings
• anonymous (3/11) May 01 2014 I guess it's not guaranteed, but constant folding should take
• Jonathan M Davis via Digitalmars-d-learn (15/29) May 01 2014 On Thu, 01 May 2014 11:12:41 +0000
• bearophile (8/13) May 01 2014 A more general solution is to wrap the concatenation with a call

"Unwise" <unwise dlang.org> writes:

In the following example from the documentation, are strings 
concatenated at compile time?

template foo(string s) {
   string bar() { return s ~ " betty"; }
}

void main() {
   writefln("%s", foo!("hello").bar()); // prints: hello betty
}

"anonymous" <anonymous example.com> writes:

On Thursday, 1 May 2014 at 10:42:36 UTC, Unwise wrote:
 In the following example from the documentation, are strings 
 concatenated at compile time?

 template foo(string s) {
   string bar() { return s ~ " betty"; }
 }

 void main() {
   writefln("%s", foo!("hello").bar()); // prints: hello betty
 }

I guess it's not guaranteed, but constant folding should take 
care of it, yes.

Jonathan M Davis via Digitalmars-d-learn writes:

On Thu, 01 May 2014 11:12:41 +0000
anonymous via Digitalmars-d-learn <digitalmars-d-learn puremagic.com>
wrote:

 On Thursday, 1 May 2014 at 10:42:36 UTC, Unwise wrote:
 In the following example from the documentation, are strings 
 concatenated at compile time?

 template foo(string s) {
   string bar() { return s ~ " betty"; }
 }

 void main() {
   writefln("%s", foo!("hello").bar()); // prints: hello betty
 }

 
 I guess it's not guaranteed, but constant folding should take 
 care of it, yes.

If you want it to be guaranteed, you'd do something like

template foo(string s)
{
    enum foo = s ~ " betty";
}

void main()
{
    writeln(foo!"hello");
}

I would hope that the optimizer would have optimized out the
concatenation in your example though.

- Jonathan M Davis

"bearophile" <bearophileHUGS lycos.com> writes:

Jonathan M Davis:

 If you want it to be guaranteed, you'd do something like

 template foo(string s)
 {
     enum foo = s ~ " betty";
 }

A more general solution is to wrap the concatenation with a call 
to:

alias ctEval(alias expr) = expr;

Use:

string bar() { return ctEval!(s ~ " betty"); }

Bye,
bearophile