On 2016-01-31 14:35:13 +0000, cym13 said:
I see things differently. First of all I don't see everyone trying
to do meta-programming with the same language. C++ for example has
a quite specific syntax between its arcane templates and the
preprocessor.
Well, ok, maybe a "using the same concepts as the underlaying language"
might hit it better.
I see having the same language as a *huge* advantage. If a function
doesn't have side effects then it can be used at runtime or at
compile-time and integrated with your logic easily.
The thing I mean is not that you shouldn't be able to reference or use
things from the "target language" but how to write down what you want
to do.
Code generation by building strings using the D operators for example
is something I think is not very elegant. If I could use a list and
build it up without having to care about the code / data difference,
that would simplify things a lot.
Imagine we could use Lua during compile time and have access to the AST etc.
D's metaprogramming success is IMHO directly linked to it not having
a separate language for it, because it lowers the cost of learning
and using metaprogramming.
But limits you to a subset that doesn't feel very natural for doing a
lot of common things in code-generation.
It's saying "metaprogramming isn't different from any other kind of
programming, you can use the same tools".
Yes, and I don't think this statement holds. It's very different
because the goal is totally different. I need a tool that allows me to
manipulate my underlying code during compilation. The main aspect is:
Manipulate D code.
Why not have a CTL (compile-time-language) that has access to some
compiler internals, that follows a more functional concept? We are
evaluating sequences of things to generate code, include / exclude code
etc.
Having access to some compiler internals is already what is done, or I
don't understand exactly what you mean by that.
Sure, but the question is how do to deal with it. IMO it's not very
straight forward at the moment.
I think you should put some sort of example of how you'd want it,
because right now I don't understand. D has some nice functional
tools and they already show their strength at compile-time.
Ok, here is a simple example: I want to ensure that specific switch
statements handle all cases for a given enum, list, etc. This is a
common pattern and often a source of problems because you change a
collection but miss to update all side-effecting places.
This is an example how I have done it (maybe there is a much better way
to do it, but I didn't come up with one):
==> BEGIN
import std.conv;
import std.stdio;
import std.string;
import std.traits;
// @@example code should work with classes as well
enum A {afoo, bfoo, cfoo};
enum members1 = __traits(allMembers, A); // returns TypeTuple
auto members2 = __traits(allMembers, A);
pragma(msg, typeof(members1));
// pragma(msg, typeid(members1)); // run-time only
// static assert(is(members1 : enum)); // Error: basic type expected, not enu
pragma(msg, typeof(members2));
// pragma(msg, typeid(members2)); // run-time only
// function that generates a string which is used as a mixin at compile time
// result string must conform to syntax as it was hand-written code
string generateEnums(T...)(string type){
string code = "enum " ~ type ~ " {";
// this is a static foreach (compile time)
foreach(m; T){
debug pragma(msg, m ~ ","); // check what code we get at compile time
code ~= m ~ ",";
}
return(code ~ "}");
}
int main(){
A switch_var_a;
final switch(switch_var_a){
case A.afoo:
case A.bfoo:
case A.cfoo:
}
string user_input = readln();
mixin(generateEnums!members1("B"));
B switch_var_b = chomp(user_input).to!B; // get rid of terminating chars
final switch (switch_var_b) {
case B.afoo:
{
writeln("a");
break;
}
case B.bfoo: // if commeted will cause a compiler error
{
writeln("b");
break;
}
case B.cfoo: {writeln("c");}
}
return(0);
}
<== END
How about being able to write something like "ensure_final_switch B;"
and have this call a CTF that generates the necessary code and has
access to tool for building D structured code, AST etc.? And has a
compile-time state I can later access in a upcoming CTF.
--
Robert M. Münch
http://www.saphirion.com
smarter | better | faster
