template X(Y)
{
string X = Y.stringof;
}
auto s = X({int 3;})
Of course, doesn't work!!
But having the ability to pass code that isn't contained in a
string is very useful!!
1. A new code keyword, similar to alias. Can only be used as
template parameters. If you are worried about backwards
compatibility, call it _code, or __code, or __code__... I don't
care, only sticks and stones hurt me.
2. The argument is only checked for syntaxical errors as the
argument. It obviously will be checked. If we allow for other
types of code besides D, then this won't work. We could extend
code to allow for other languages(which would require their
syntax checking algorithms): code(python).
e.g.,
template PythonParser X(code(python) pythoncode)
{
// Parses pythoncode and coverts it into D or passes it to
the python interpreter or whatever...
}
In this case, D will know it is python code, check for a python
code parser and deal with it(use an external lib to check it or
have built in grammars for such things).
No code is ever actually executed by this extension in the
compiler, so it's somewhat of a trivial addition. All the
processing is added by the programmer.
3. stringof returns the code as a string. e.g.
pythoncode.stringof is simply the string representation of the
block of code passed.
This complements D's mixin mechanisms by getting out of having to
put code in strings, which are nearly a clusterfuck for complex
code.
4. This opens the door to allow for one to migrate code easier to
D. Suppose you have to transfer a large code base in, say,
javascript. Instead of having to convert it all by hand, you
could have something like
template IncludeJS(code(javscript))
{
magiccookie(javscript.stringof);
}
... converts and integrates the javascript code into D or simply
interprets it and returns the error code, or whatever. It's not
unfeasible to think that someone could write the magiccookie that
brings in all the objects, functions, and such into D to be
consumed in D code. I've seen this done for several scripting
languages such as lua and js.
