On 10/10/2009 00:36, Christopher Wright wrote:
Yigal Chripun wrote:
On 09/10/2009 00:38, Christopher Wright wrote:
It makes macros highly compiler-specific, or requires the compiler's AST
to be part of the language.
Nemerle took the nuclear option, and its macros are all-powerful. That's
a reasonable way of doing things. I'd be happy with a more restricted
system that's easier to standardize, especially if it got rid of all the
hacky string manipulation in current D metaprogramming. (Seriously, even
__traits returns string arrays for a lot of stuff. It's ridiculous.)
It doesn't have to be compiler specific. all is needed is a
standardized API to the compiler.
Right. It adds something huge that's normally compiler-specific to the
language. This makes me uncomfortable. It greatly increases the
difficulty of implementation.
I disagree - a properly designed compiler will have such an API anyway.
Look at how Clang is designed - it's a modular compiler where each part
has its own library. you can combine its libs in different ways to
provide different options: a full command-line compiler, semantic
analysis for IDE, incremental builder for an IDE, etc..
that design obviously requires APIs for the different components.
What's so hackish about that?
Reread. Current D metaprogramming is hackish. Nemerle's isn't.
I was referring to what Don said that providing a hook into the compiler
is hackish.
many large modular systems do exactly that: eclipse, firefox, even the
OS itself. Unix provides syscalls which *are* an API to the OS.
a properly designed API doesn't have to expose internal implementation
details.
btw, in Nemerle they have syntax to compose/decompose AST specifically
so they don't need to expose the internal structure of the AST.
So they have a separate object model for the syntax tree that macros can
affect. This is what I would recommend for D.
What do you mean by object model?
they have a synax to manipulate AST:
<[ some code ]> would be parsed by the compiler as the AST of "some
code" and would be represented internally by the compiler specific AST
representation.
This syntax also handles hygiene and provides means to break it when needed.
