E>А то я наблюдал, как при передачи статей в журнал некоторые научные деятели намеренно в сложных формулах мелкие ошибки делали (например, кое-где плюсик на минус поменяют). Чтобы никто просто так результатами трудов не воспользовался

namespace Oyster
{
  public module Math
  {
    // Просто метод, который просто считает факториал в рантайме
    static public Fact(x : int) : int
    {
      | 1 => 1
      | _ =>
        if (x > 1)
          x * Fact(x - 1)
        else
          throw ArgumentException("x")
    }
  }
}

O>namespace Oyster
O>{
O>  public module Math
O>  {
O>    // Просто метод, который просто считает факториал в рантайме
O>    static public Fact(x : int) : int
O>    {
O>      | 1 => 1
O>      | _ =>
O>        if (x > 1)
O>          x * Fact(x - 1)
O>        else
O>          throw ArgumentException("x")
O>    }
O>  }
O>}
O>

template< int N >
struct Factorial {
    enum { value = N * Factorial< N-1 >::value };
};

template<>
struct Factorial< 1 > {
    enum { value = 1 };
};

template<>
struct Factorial< 0 > {};

E>то мне кажется, что она получается в более функциональном стиле, что ли

fun(x)
{
    | 0 => ...
    | 1 => ...
    | _ => ...
}

fun(0) = ...
fun(1) = ...
fun(x) = ...

E>Вот только синтаксический оверхэд в виде template<> struct под ногами путается

E>Зато компилятор не дает вычислять факториал нуля

E>Вот только синтаксический оверхэд в виде template<> struct под ногами путается

import std.stdio;

// можно и специализацию использовать(или вообще тернарный оператор ? : )
// но я намеренно выбрал самый непохожий на C++ вариант
template fact(uint n)
{
    static if (n <= 1)
        const ulong fact = 1;
    else
        const ulong fact = n * fact!(n - 1);
}

void main()
{
    auto x = fact!(6);
    auto y = fact!(50);
    // 720 15188249005818642432
    writef("%d %d\n", x, y);
}

E>Зато компилятор не дает вычислять факториал нуля

fact(n : uint) : ulong
{
  | 0 => 1
  | 1 => 1
  | _ => (x :> ulong) * fact(x - 1) 
}

VK>А теперь вариант на D. Как говорится почувствуйте разницу.

E>>Зато компилятор не дает вычислять факториал нуля

template< int N >
struct Factorial {
enum { value = N * Factorial< N-1 >::value };
};

template<>
struct Factorial< 0 > {
enum { value = 1 };
};

E>Кстати, я забыл, в результате работы макроса можно ли сгенерировать код, который внутри к другому макросу будет обращаться? Т.е. обращение к макросу не внутри тела макроса, в том коде который макрос производит? Что-то на эту тему было, но уже не помню где

  macro FactRec(expr)
  {
    match (expr) {
        | <[ 0 ]> => <[ 1 ]>
        | <[ 1 ]> => <[ 1 ]>
        | <[ $(x : uint) ]> => 
              <[ $(x : ulong) * Oyster.Macro.FactRec($(x - 1 : uint)) ]>
        | _ => <[ Oyster.Math.Fact($expr) ]>
    }
  }

 >                 valarray<type>    tr(2);                                             \
type tr[2];
 >                                                                                      \
 >                 tr[0] = rhs.real();                                                  \
 >                 tr[1] = rhs.imag();                                                  \
 >                                                                                      \
 >                 type            mixam = static_cast<type>(1)/(abs(tr).max)();        \
 >                                                                                      \
 >                 tr *= mixam;                                                         \
 >                                                                                      \
 >                 valarray<type>    tt(4);                                             \
type tt[4];