Memoization in compile-time

[Meta via Digitalmars-d-learn]

On Friday, 13 March 2015 at 12:49:48 UTC, Dennis Ritchie wrote:
> On Friday, 13 March 2015 at 02:38:18 UTC, Rikki Cattermole 
> wrote:
>> You could assign it to e.g. an enum. Or force it over using 
>> meta-programming.
>
> And this code can be rewritten to D?
>
> template <int n>
> struct Factorial
> {
>     enum { value = n * Factorial<n - 1>::value };
> };
>
> template <>
> struct Factorial<0>
> {
>     enum { value = 1 };
> };
>
> int main()
> {
>     constexpr auto x = Factorial<5>::value;
>     constexpr auto y = Factorial<7>::value;
> }

You can translate it directly:

template Factorial(int n)
{
     static if (n == 0)
     {
         enum Factorial = 1;
     }
     else static if (n > 0)
     {
         enum Factorial = n * Factorial!(n - 1);
     }
     else
     {
         static assert(false, "n cannot be negative");
     }
}

int main()
{
     //Calculated at compile time
     auto x = Factorial!5;
     auto y = Factorial!7;
}




However, it's much easier to just write a function and decide 
whether you want to calculate its value at runtime or compile 
time.

int factorial(int n)
in
{
     assert(n >= 0, "n cannot be 0");
}
body
{
     return n == 0 ? 1 : n * factorial(n - 1);
}

void main()
{
     //Evaluated at compile time
     enum x = factorial(5);

     //Evaluated at runtime
     auto y = factorial(7);
}