DIP 1027---String Interpolation---Format Assessment

[SealabJaster]

On Thursday, 27 February 2020 at 09:30:30 UTC, Walter Bright 
wrote:
> You can make it behave like all those other languages simply 
> with:
>
>     f(format("hello $a"));

At that point, it begs the question of why even bother having 
string interpolation.

I'd like to imagine that most newcomers/returning veterans of D 
would see "D has string interpolation!" and then expect it to 
work similar to how it does in most other languages.

They'd expect f(format("hello %s", a)) to be replaced by a much 
more compact f("hello $a"), instead of some D-ism take on 
interpolation that doesn't really provide much in the way of the 
main use of the feature: easily creating formatted strings.

People more used to D will likely go "Oh, that's kind of weird 
yet cool" once they learn what it lowers down to, yet newcomers 
who aren't too caught up with the language's features will simply 
be annoyed and confused that it 'feels' (not necessarily is) more 
complicated than needed.

It appears the main focus in these dicussions are "What super 
super cool and niche (in comparison to string formatting) things 
can we do with this feature!" while mostly blind-siding that it's 
generally an easy-to-use, easy-to-understand feature in other 
languages.

Similarly, as far as I can tell even with the adjustment of 
making these strings their own special type, something as simple 
(for other languages as):

```
void f(string a, string b)
{ /*...*/ }

int foo = 20;
string bar = "lalafell";
f(i"You are a foo($foo)", i"I am not a $bar");
```

Isn't easily achieved without use of an extra helper function 
such as i"...".format or .str, etc.

My view on it is that this is generally a QoL feature, which some 
languages (C#, Swift) have had success in keeping the basic 
principle of interpolation while also granting user code the 
power to perform some of the things being suggested (e.g. In C#, 
string interpolation works as-expected, yet check out functions 
such as FromSqlInterpolated[1] which can directly access the 
format string & values simply by taking a special 
`FormattableString` type)

To be honest, if D's take on interpolation makes people scratch 
their head in confusion at the most basic use case, then it's 
probably not even worth adding to the language.

[1] 
https://docs.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.relationalqueryableextensions.fromsqlinterpolated?view=efcore-3.1