Meta-programming - examples

[janderson]

A couple of people have been asking questions about pseudo-real-life 
examples for the new compile time code aspects of D.  I ask this 
question for my interest as well.

Assuming that we have a good mechanism to process the input how could 
compile time code improve your every-day proficiency?  (This is 
specifically about the Mixin Expressions aspect).

I'll start with a few of my own.  Note my background is
game-programming.  In my experience, we care constantly creating tools 
to generate code because its impracticable to write and maintain it by hand.

Statemachine (and AI logic) written by design and coders are common in 
game programming.  Normally we have to fallback on a script language 
which is never as powerful.

mixin(statemachine(
"
	state FireAtEnemy
	{
		transition EnemyRange < 10
		{
			goto ChaseEnemy
		}
		transition FacingEnemy < .2
		{
			goto ChaseEnemy
		}
	}

	state ChaseEnemy
	{
		...
	}

");

You might imagine doing the above with if statement and arrays of 
delegates however designers have a much harder time with that.

3D Object rendering

//Render a 3D model.  For instance this may generate the vertexbuffers 
and textures directly into code, or may extract some of the data from 
the 3Dmodel.obj and load the rest at run-time.
mixin(renderModel(import("3Dmodel.obj")));

Transforming Textures
DXDtexture* texture = mixin(textureToD3D(import("3Dmodel.bmp")));

Simplify saving/loading of arbitrary structures.

//Only write this once.  Things are re-ordered for best fit in memory, 
localization ect...
mixin(Serailzable("Ship",
"
	struct Part
	{
		float firePower;
		char[] Model;
	}

	struct Ship
	{
		bool Friendly;
		Part Parts[];
	}
");

... Later

Load("Ship", "Ship.asset");

GUI -> not sure about this one as I can't come up with a format thats 
much neater then straight code. I'll post it anyways.

mixin(MyGUI(
"
	Button "OK", 10, 30
	{
		Exit;
	}
");

Multi-threading

The suggestion with multi-threading I came up with a little while ago:

int[] array ...
int result = 0;
mixin(threadIt(
"
	foreach(A a; array)
	{
		result += a;
	}
	combiner //If necessary?
	{
		result = result[0] + result[1];
	}
");

Compile time checking of code for coding standards or what have u:

mixin(CheckCode("

ect...


");
//Note that there should be a way to disable CheckCode in the general 
case to save compile time


There's heaps of other stuff, but that would make this post way to long.

Personally I see this new mixin format as giving us the power to extend 
D in whatever way meets our goals.  As Walter adds more features some of 
them will be rarely used (law of demising returns) because they are 
special case.  Mixin Expressions circumvent this because now the 
programmer has the power to create the language features they need.

The only downside I see is compile-time, which I hope can be solved with 
a smart caching system.