Interpolated strings

[bpr via Digitalmars-d]

On Wednesday, 19 April 2017 at 00:30:31 UTC, Walter Bright wrote:
> I'm not saying you cannot do cool and useful things with AST 
> macros. My position is it encourages absolutely awful code as 
> (usually inexperienced) programmers compete to show how clever 
> their macros are.

I'd think that that's a problem with community coding standards.

> The language gets balkanized into a collection of dialects that 
> are unrecognizable across user groups.

I'm pretty sure that hasn't happened with every language that 
supports macros. Even in the case of Scheme, I don't think it's 
the macros that are responsible for all of the dialects. It's the 
fact that the core language never includes enough (no records, 
exceptions, modules, ...) so every group adds their own versions 
of these features. Maybe if macros didn't make that easier then 
Schemers would have added those things to the core, but that's a 
counterfactual that I don't find convincing.

> As a compiler dev who gets stuck figuring out users' bug 
> reports, dealing with templates is bad enough (the first thing 
> I do with a bug report is redo it to remove all the templates). 
> I do not want to deal with some custom syntax. If I may pull 
> the "I'm older" card, programmers will find as they gain 
> experience that the AST macros are just not worth it.

Some programmers will not find that. Others will find that other 
features you value are just not worth it. There are absolutely no 
categorical statements. :-)

> This disastrous state of affairs has occurred with every 
> language that supports macros.

I don't think I've ever heard from Common Lisp, Scheme or Clojure 
programmers that they'd like to remove macros from their 
respective languages for the reasons you mention. I don't see the 
disasters there. The Julia folks looked at the Lisp experience 
and decided to include macros.

Both Rust and Nim support macros. Scala too. Not long enough for 
the disaster yet?

It's certainly not all roses, and writing and debugging macros 
can be a PITA. I try to avoid them, and consider them a tool of 
last resort. But they're very powerful, and sometimes I'm not 
smart enough to figure out how to do what I want cleanly with 
less powerful features.

> If you want a nauseous example, check out the Boost C 
> preprocessor metaprogramming library. Or C++ expression 
> templates - so cool, and yet so utterly wretched.

Have you checked out examples of macros that are not so 
nauseating? I find Nim decent, and of course the Lisps have a 
long history of macrology. I think you're drawing a view of 
macros from cpp, and MASM, and such, and not so much from the 
Lisp family, or Nim. cpp macrology is very different!

D is interesting to me mostly because of it's powerful templates 
and CTFE. It seems a shame (to me, obviously) that such a 
powerful static metaprogramming feature as macros will not be a 
part of D, but it's your language!