Why not move cast to the standard library?

[Yigal Chripun]

On 25/09/2009 18:32, Robert Jacques wrote:
> On Fri, 25 Sep 2009 03:29:21 -0400, Don <nospam at nospam.com> wrote:
> [snip]
>> A bit of history: A macro system was planned for D2, and 'macro' was
>> made a reserved word. But in discussions at the end of the first D
>> conference, I demonstrated that the combination of CTFE + string
>> mixins, even in D1, was dramatically more powerful than the proposed
>> macros. It became clear that we didn't have a macro design that was
>> anywhere near powerful enough, and macros were postponed to D3. We
>> don't know how they should work.
>> By all means make a proposal.
>
> About the only thing I find lacking today is the ability to do zero
> weight expression templates. I think fleshing out the alias keyword
> might do the trick (i.e. alias tuples + alias function parameters) but I
> haven't though it all through.

My preferred design, which I can't imagine implemented in the near 
future, would be something in these lines:
(disclaimer: heavily influenced by Nemerle)

1. macro definitions are separate from regular code. Macros are compiled 
into libs that are loaded by the compiler:
something like:
dmd --load-macro=my_macro.dll mysource.d
(can be implemented as DDLs for portability)

2. macros contain regular D code and can use facilities from the stdlib 
to manipulate their input (examples will follow)

3. macros can either be called from regular code with function call 
syntax or by using an attribute system to specify hook points.
e.g.
int result = max_macro(50, 90); //  transformed to: "int result = 90;"

[macro(params)] // some imaginary attribute/annotations syntax
class Class { .... }

examples of macro definitions:
a) CTFE replacement:
macro max(int a, int b) {
   return (a > b) ? a : b;
}

b) operate on the current AST node:
/// stdlib provided utilities to work with the AST
import Compiler.AST;
import Compiler.parser;

macro (AST input) {
// input is set by compiler to the current AST sub-tree
   return some_ast_transform(input);
   // can call regular functions to implement macros
}

c) compile-time vs. run-time :

macro () {
    Stdout("Compile time").newline; //printed at compile-time
    return AST("Stdout(\"Run time\").newline;"); //printed at run-time
}

The Compiler package above provides facilities for the programmer to 
directly manipulate the AST in a standard way with API calls instead of 
string manipulations.