Doo de doo.. *google homoiconic*... program representation is data structure of primitive type of language or somesuch

Hm.

templates are advance metaprogramming capabilities, string mixins are quite primitive, and ctfe is too immature to say one way or the other.

In my mind, the advantage of a homoiconic language is not so much the ability to generate code (though it is pain when your language doesn't have that) as it is the ability to manipulate code. First, that presupposes a real data structure which can be manipulated. Second, since your code is represented the same way as any other data, your meta programming code isn't any different from other code. Two strengths: 1) you're working with the language; given the operators and syntactic support your meta programming should be fairly eloquent. 2) you get to use the same libraries as you do for everything else.

You can probably see where I'm going.

Strings are an able medium for generating code. They're pretty fundamental and generating code-as-string is a snap. However, once you have that string, you really can't do anything with it except pass it to the compiler. You can't even insert or replace some piece of code with another (with special cases you can, but special cases are fragile and break quickly whenever you want to do something slightly different). This limits how you can perform string generation. Whereas with templates, you see the top level code with some small pieces which get customized, with string generation you have to generate those small pieces first, and then progressively concatenate things around them. In terms of string operations, that may be eloquent, but in terms of code, it is rather unreadable.

Then there's the fact that the compiler doesn't represent code as strings. If the compiler exposed the AST, all this might be less of an issue. ASTs aren't a primitive type, but D's library capabilities are strong enough that you might be able to design an AST such that AST manipulation doesn't suck as much as in other c-style languages. It wouldn't be much more readable than string generation, though.

At best, its an implementation issue, as is ctfe (unless something's changed recently, you can't program ctfe in idiomatic D. bad.)

In short, D isn't there yet.

On 10/21/2010 09:51 AM, Justin Johansson wrote:
Nothing about this subject line is purported to be
true or false or otherwise conjectured; the subject is
simply proposed as a topic for debate.

The formal subject proposed for debate is
"D's advanced meta-programming capabilities essentially
makes it (D) as if it were a homoiconic language, and
brings with it all the advantages of homoiconic languages."

Hoping this is a nice topic for all to enjoy and to participate in.

Cheers
Justin Johansson

Reply via email to