Reconsidering the syntax of $R"(text)"

[msadeqhe]

IMO $R"(text)" is an example of too smart syntax for raw interpolated string literals. It's visually misleading especially with captures. This is an example for code generation:

func_signature: = "(x: i32)";

// What does it mean?
call(: (func_signature)$R"(text)");

// Case 1
call(: (func_signature)$ R"(text)");
// `call(: (x: i32) R"(text)");`

// Case 2
call(: (func_signature) $R"(text)");
// `call(: (func_signature: _) $R"(text)");`

abc: i32 = 10;
var_name: = "abc";

// Also it looks like $ is a quote here:
$R"(the_(var_name)$)"$: i32 = 20;
// `the_abc: i32 = 20;`

The example doesn't work today and I don't know if we can use captures to specify a function signature in code generation, or if we can capture from raw interpolated string literals. Also the white-space can be used to resolve the ambiguity, but $ itself is visually misleading to form a string literal if we consider readability. Also it requires more characters to type. Would it be possible to reconsider changing the $R in syntax $R"(text)" to a single letter?

• r"(text)", because r isn't as strong as R.
• I"(text)", because I is the first letter of Interpolated.
• S"(text)", because S visually looks like $.
• or any other single letter which has a closer meaning than others.

Thanks.

[JohelEGP]

I see no captures outside strings here.
None of those $ symbols outside strings is a postfix-operator.

[msadeqhe]

Doesn't $ in case 1 captures func_signature? Currently we cannot author meta functions in Cpp2, so imagine that my example was the code generation part of authoring a meta function.

[JohelEGP]

func_signature: = "(x: i32)";

// Case 1
call(: (func_signature)$ R"(text)");
// `call(: (x: i32) R"(text)");`

That's just a grammar error.

[JohelEGP]

What about one minute starting at https://youtu.be/8U3hl8XMm8c?t=1898.
Injection in the reflection API is through strings.

[msadeqhe]

Thanks @JohelEGP, so the implementation and code generation would be something similar to this:

func_signature: = "(x: i32)";

// Which one does it mean?
x.add_member($R"x(  func: (func_signature)$R"(text)"  )x");

// Case 1 -------> `func: (x: i32) R"(text)"`
x.add_member($R"x(  func: (func_signature)$ R"(text)"  )x");

// Case 2 -------> `func: (func_signature) $R"(text)"`
x.add_member($R"x(  func: (func_signature) $R"(text)"  )x");

According to the question, Case 1 is the answer. It would be possible to require programmers to add extra white-space if they want Case 2. But requiring white-space can be relaxed if we had another syntax for raw interpolated string literals.

Requiring white-space in Cpp2 syntax, would make it hard to arbitrary format the code. In other words, less white-space requirements brings better code format options.

I (as a novice programmer) learned to think about $ as a postfix operator, while $ has two different meanings. Either:

• it would capture a variable (postfix operator): var$
• or it would mark a raw string literal to be interpolated (prefix mark).

That's not a problem, a symbol can have as many meanings as it doesn't conflict with each other, but while generating code inside a meta function, it would be desirable that $ has only one meaning.