Existing efforts to create a template system have been
based on the mind-set of the C preprosessor.

Did some thinking...  :-)

What is the template system?
I think it is a language for transforming things. Not
entirely unlike the regex thing. The Template System (TS)
takes, what is essentially, "a multi line string",
from possibly several separate places in the source.
It also takes function signatures, and outputs "strings
that look like customized function definitions", which
it inserts into the source input stream. (In spirit, at
least.)

So, it is a language. A year ago I read that somebody had
discovered that the C++ TS is actually a Turing Complete
(TC) language. (Googling around I found e.g.:
http://homepage.mac.com/sigfpe/Computing/sk.html
where it is discussed quite well.)

So?

In hindsight, can it be, that TC is a required property
of a well functioning TS ?? If this is really true, then
we should consider TC from the outset, and just build
a language from that point of view.

----------

If this is the case, then two origins come to mind, off
hand. Either base it on Lambda Calculus, or make just
another Procedural Language (PL).

While I personally would do it with PL, my reasons would
only be that it is easier to grasp.   :-(

OTOH, a TS based on Lambda Calculus might bring truly
stunning power, flexibility and expandability.

Problem is, LC might not be too familiar to all, and
even worse, such a system might (?) result in a template
language that is also "unfamiliar looking" to the
"C language family" kind of programmer.

Actually, developing and prototyping this language would
be quite fast with Lisp or Scheme. But it might be also
reasonably easy and fast with D itself? (Both LC and PL
development can be done with all three.)

Another tack could be using Yacc, or some such?

----------

Any thoughts?

georg

PS: (( A not-so-serious idea, what if we cavalierly just
took an existing language and decided to use it as our
template language? Say, a subset of Lua or Euphoria??
Or DMD-Script? ))   ;-)

In article <4215B2C8.7030706@nospam.org>, Georg Wrede says...
>
>
>Existing efforts to create a template system have been based on the mind-set of the C preprosessor.
>
>Did some thinking...  :-)
>
>What is the template system?
>I think it is a language for transforming things. Not
>entirely unlike the regex thing. The Template System (TS)
>takes, what is essentially, "a multi line string",
>from possibly several separate places in the source.
>It also takes function signatures, and outputs "strings
>that look like customized function definitions", which
>it inserts into the source input stream. (In spirit, at
>least.)
>
>So, it is a language.

Yes, I was looking at the C++ template system a while back
and I came to the realization that it reminded me of a functional
language.  Ok, the resemblance is slight but the template system
has two things in common with functional languages.

1. Functional languages often use pattern matching for conditionals. This is similar to using template specialization.

2. They use recursion for there looping constructs.

I think the grand revelation behind all this is that a program
is just data like every thing else.  The lisp people had this
figured out a long time ago.  With lisp that programming language
and data representation is one in the same so you can write programs
to manipulate programs.

For C++ and D it always seem like a little bit of a disjoint that what is basically a procedural language needs a functional like language for templates.

One of the things I've been looking at lately is a .NET language called Boo (http://boo.codehaus.org/).  It's interesting because it has an extensible compiler pipeline.  It has a module that will render the code into an AST and then modules that will render the AST into .NET IL. You can write code in Boo ( or any other .NET language ) to rewrite the AST tree and insert it into the compiler pipeline.  When you combine this with the ability to tie custom attributes to any function or data member as well as add you own keywords you get a pretty powerful language extension system.  THe nice thing is the extensions can be written in the same language and the rest of the code.

This is all well and good for .NET.  What the solution is for more a more static language like D I don't have an answer for.

(OT:
Damn, there are still a few rough edges in the Thunderbird
mail client Composer. Sometimes it has a hard time knowing
what is quoted or not.)

Patrick Down wrote:
> In article <4215B2C8.7030706@nospam.org>, Georg Wrede says...
> 
>>
>>Existing efforts to create a template system have been
>>based on the mind-set of the C preprosessor.

<snip>

> Yes, I was looking at the C++ template system a while back
> and I came to the realization that it reminded me of a functional
> language.  

Right. Seems that we really should give this some thought, and not
just go on the old way.

> For C++ and D it always seem like a little bit of a disjoint that
> what is basically a procedural language needs a functional like
> language for templates.

Yes.

OTOH, I think D should remain a procedural language. In fact, IMHO
it's about as good as can be imagined, already! From this point of
view, the disjointness between the language "itself" and its
template system may be a good thing. People who come to D expect
a procedural language, and changing that might slow down the
inflow of new talent, or the adoption of D.

Folks can get up to speed quickly with D. And because of this
disjointness, the line between "mundane" and "esotheric" stays
visible. Compare that to C++, where _everyone_ feel incompetent
because there is no "visible" distinction between the different
areas in the language. At the end of the day a professional C++
programmer feels guilty for still not having learnt it all.

Well, that distinction wasn't all that important. But what is, is
that the two-language-in-one paradigm, where you essentially have
a compile time language and a runtime language, is quite
powerful. And seems "natural" to many, at least in the markets
we're out to get. (The audience screams "Get Stroustrup! Haddaboy!
Now get Gosling! Go, go, go! Get Wall, get Hejlsberg! Kernighan!")

> One of the things I've been looking at lately is a .NET language called Boo (http://boo.codehaus.org/).  It's interesting because it has an extensible compiler pipeline.  It has a module that will render the code into an AST and then modules that will render the AST into .NET IL.  You can write code in Boo ( or any other .NET language ) to rewrite the AST tree and insert it into the compiler pipeline.  When you combine this with the ability to tie custom attributes to any function or data member as well as add you own keywords you get a pretty powerful language extension system.  THe nice thing is the extensions can be written in the same language and the rest of the code.
> 
> This is all well and good for .NET.  What the solution is for more a more static language like D I don't have an answer for.

My gut feeling (so far nothing more) says this is an incredibly
important issue.

I wonder, the preprocessor needs of D and C++ are different.
But what actually makes this differece?