[OT] C# can do all the interpolated strings now

[WebFreak001]

On Thursday, 9 December 2021 at 14:57:25 UTC, Steven 
Schveighoffer wrote:
> On 12/9/21 9:25 AM, WebFreak001 wrote:
>
>> Love the idea of having type-safety with this! JS has similar 
>> syntax with `` sql`...` `` where it will call the function 
>> `sql` with the parts of the interpolated string.
>> 
>> https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
>> 
>
> This is exactly what the proposal is doing. But instead of 
> using `sql` as a specialized prefix (you have to be careful 
> with these, as adding arbitrary literal prefixes can mess up 
> the grammar) it's just a parameter tuple, and you specify the 
> function as normal.
>
> i.e. this is practically identical to:
>
> ```d
> sql(i"SELECT x,y,z FROM $something WHERE $condition");
> ```
>
> Or even:
>
> ```d
> i"SELECT x,y,z FROM $something WHERE $condition".sql;
> ```
>
> -Steve

I think identifiers immediately followed by a string literal are 
unambiguous. Currently a syntax error, afterwards useful 
interpolation.

The i"" proposal allows to pass multiple arguments at once, and 
with that adds new cases to the compiler that a single literal 
can be multiple arguments. The identifier + string literal stays 
within bounds of existing behavior.

I think you would really really never want to pass these raw 
tuple values to any function other than to explicitly designed 
interpolated string handlers.

Given that assumption I think it's safe to say the `i` prefix is 
redundant, and you should just always need to use a handler 
function. The identifier + string literal syntax elegantly does 
this without redundant syntax, it's familiar to JS programmers 
and it doesn't allow passing more than the interpolated string to 
handler functions or functions with variadic arguments. (which is 
a good thing)

Samples:

```d
sql(i"SELECT x,y,z FROM $something WHERE $condition")
text(i"hello $name")
mixin(i"class $name {}")
```

vs

```d
i"SELECT x,y,z FROM $something WHERE $condition".sql
i"hello $name".text
mixin(i"class $name {}") // no equivalent
```

vs

```d
sql"SELECT x,y,z FROM $something WHERE $condition"
text"hello $name"
mixin"class $name {}"
```

or have some kind of new function call punctuation:

```d
sql$"SELECT x,y,z FROM $something WHERE $condition"
text$"hello $name"
mixin$"class $name {}"
```

---

and if you want to actually access the tuple for variadic 
template arguments (including the header) you could still do this:

```d
AliasSeq"hello $name"
```

(or `alias I = AliasSeq;` and `I"hello $name"`)