Cheaper compile-time tests

[bearophile]

This is from the office of not so useful things. If you try to 
fake dependent types in D you end instantiating many times the 
same template, inflating the binary with little purpose (because 
you are not very interested in the optimizations performed on the 
compile-time-known values). So to help that kind of coding I am 
thinking about something like this:



int foo1(@generic int c)(int x) if (c > 5) {
     return c * x * x; // foo body
}
void main() {
     auto r1 = foo1!(10)(15);
}



Its semantics is similar to this, but foo2() doesn't exists in 
the binary:


int foo2__(int c, int x) {
     return c * x * x; // foo body
}
int foo2(int c)(int x) if (c > 5) {
     return foo2__(c, x);
}
void main() {
     auto r1 = foo2!(10)(15);
}



So it's closer to this:


int foo3__(int c, int x) {
     return c * x * x; // foo body
}
void main() {
     enum int c = 10;
     static assert(c > 5, "required by foo");
     auto r1 = foo3__(c, 15);
}


So it looks like a function templated on some value, but you are 
instead calling a normal run-time function that requires the 
first arguments must be known at compile-time, and they get 
verified by template constraints.

So all this is just a way to perform compile-time tests on 
values, avoiding the instantiation of many useless templates. 
Those tests are one of the two halves of the tests of dependency 
of the types :-)

Bye,
bearophile