The original idea with the "macro" keyword was to introduce AST macros.
Although nothing has happened yet. People have been talking about it
from time to time but no one has had a real proposal.
I've got this: https://dl.dropboxusercontent.com/u/18386187/ast_macros.html
But I haven't turned it into a DIP (D Improvement Proposal) yet.
--
/Jacob Carlborg

The original idea with the "macro" keyword was to introduce AST
macros. Although nothing has happened yet. People have been
talking about it from time to time but no one has had a real
proposal.
I've got this:
https://dl.dropboxusercontent.com/u/18386187/ast_macros.html
But I haven't turned it into a DIP (D Improvement Proposal) yet.

This is amazing, its not 100% perfect but it hits all the main
things I want out of a macro system. How long ago did you come up
with this?

The original idea with the "macro" keyword was to introduce AST
macros. Although nothing has happened yet. People have been
talking about it from time to time but no one has had a real
proposal.
I've got this:
https://dl.dropboxusercontent.com/u/18386187/ast_macros.html
But I haven't turned it into a DIP (D Improvement Proposal) yet.

My favorite part was the statement macros and the attribute
macros. I want this so much.

The original idea with the "macro" keyword was to introduce AST
macros. Although nothing has happened yet. People have been
talking about it from time to time but no one has had a real
proposal.
I've got this:
https://dl.dropboxusercontent.com/u/18386187/ast_macros.html
But I haven't turned it into a DIP (D Improvement Proposal) yet.

This would be a perfect and much classier replacement for mixins
in most situations.

Hi!
As far as I can remember, macros have been deferred to D3 because
it has mixins and templates, so one can easily manipulate code in
D. However, it's been long time since there was serious
discussion about the implementation details. I'm happy to see
that the topic emerged again just before DConf - maybe the
discussion will continue there.
Several non-lispy languages introduced macros long ago so the
developers may learn from others mistakes and they will avoid the
pitfalls. These languages include Groovy,
Scala, Nimrod and Rust.
The Rust implementation is much like text substituation when
used, so one can easily learn it in an hour. Its syntax is a
little distinct from the base language, and there has been a
problem with lexing it according to a past issue:
https://github.com/mozilla/rust/issues/2755
It's still unfinished, there are some limitations. ( although
it's been always hard to debug them ) Have a look at:
http://static.rust-lang.org/doc/0.6/tutorial-macros.html
and also see the language manual ( at http://rust-lang.org )
Beyond AST macros, Nimrod ( http://nimrod-code.org ) has text
substituation mechanisms called templates - much like C macros or
templates in C++ and D. It also has term rewriting macros. In my
opinion, Nimrod is a language where a lot of features can produce
dirty code ( although some of them are very well done and they
are extremely powerful tools ), and it's the developer's choice
to use the features for the right purposes ( especially true with
term rewriting ).
So obfuscation is just as easy in that language as in C++ or
Perls before version 6 despite the fact that its sysntax is
derived from Python.
I can't say much about Scala and Groovy, but their syntax for
defining macros doesn't use as cryptic symbols as Nimrod. For
example I couldn't find out for first time what is nnk the nnk
prefix in the nnkInfix symbol.
Zsombor

Hi!
As far as I can remember, macros have been deferred to D3 because it has
mixins and templates, so one can easily manipulate code in D. However,
it's been long time since there was serious discussion about the
implementation details. I'm happy to see that the topic emerged again
just before DConf - maybe the discussion will continue there.
Several non-lispy languages introduced macros long ago so the developers
may learn from others mistakes and they will avoid the pitfalls. These
languages include Groovy,
Scala, Nimrod and Rust.

Beyond AST macros, Nimrod ( http://nimrod-code.org ) has text
substituation mechanisms called templates - much like C macros
or templates in C++ and D. It also has term rewriting macros.

Nimrod's templates do operate on the AST too, they don't perform
text substitution.

In my opinion, Nimrod is a language where a lot of features can
produce dirty code ( although some of them are very well done
and they are extremely powerful tools ), and it's the
developer's choice to use the features for the right purposes (
especially true with term rewriting ).

Term rewriting macros can be turned off on both local and global
levels to ensure they don't affect semantics. You can also
exclude a TR macro symbol explicitly in an "import" statement
(import module except broken_tr_macro) should the transformation
turn out to be buggy.

So obfuscation is just as easy in that language as in C++ or
Perls before version 6 despite the fact that its sysntax is
derived from Python.

The idea that a statically typed language with checked exceptions
and an effect system (both features which didn't make it into
0.9.0 though) is somehow less maintainable than Python with its
dynamism everywhere is absurd.

I can't say much about Scala and Groovy, but their syntax for
defining macros doesn't use as cryptic symbols as Nimrod. For
example I couldn't find out for first time what is nnk the nnk
prefix in the nnkInfix symbol.

Admittedly the macros API has been rushed out and the nnk
prefixes are ugly. However there are addons that improve on the
API. The core API will be improved too but it needs some
transition path as unfortunately quite some code now depends on
it. ;-)