[debate] About D's pretension for homoiconicicity

[Ellery Newcomer]

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