D seems interesting, but...

[foobar]

On Monday, 15 October 2012 at 13:11:29 UTC, bearophile wrote:
> Adam D. Ruppe:
>
>> You could just version it:
>>
>> version(foo_main)
>> void main() {}
>
> That's not good enough.
>
> What I as talking about is: when the D compilers know a module 
> is
> the main module, it defines a _standard_ version boolean flag,
> named like "is_main_module" as true. And it gives a compiler
> error if it can't find a main. Otherwise "is_main_module" is
> false.
>
> It's meant to be used as:
>
>
> module modulea;
> int foo() { return 0; }
> static if (is_main_module) {
>    unittest {}
>    void main() { // demo code
>      import std.stdio;
>      writeln(foo());
>    }
> }
>
>
>
> module moduleb;
> import modulea;
> int bar() { return 1; }
> static if (is_main_module) {
>    unittest {}
>    void main() { // demo code
>      import std.stdio;
>      writeln(foo());
>      writeln(bar());
>    }
> }
>
>
> When you compile modulea, defines its is_main_module as true, it
> runs its unittests (if you have used -unittest), and its main,
> that is a demo for the A module.
>
> If you compile the moduleb (with rdmd or something), it knows
> moduleb has to contain the main, it defines is_main_module=true
> in moduleb and defines is_main_module=false for modulea. So it
> compiles the main of moduleb and ignores the main of modulea. So
> it runs the demo code for moduleb only.
>
> Using a non-standard user-defined version as you suggest misses
> all this, and it's not good enough. Standardization and
> automation is important here.
>
> Bye,
> bearophile

I'm sorry to say but that *is* a _horrible_ _hack_. It looks 
almost as awful as it does in python with the underscores.

Java has the correct DRY solution - each class can define a 
static main method but the compiler only uses the one specified 
by a compiler switch.
The above basically asks the programmer to endlessly repeat the 
same trivial implementation boilerplate that should be written 
just once _in_ the compiler.