Помогите определить тип в макросе
заготовка:

macro determine_type(e)
{
    WriteLine($"Determining type of $e ..");
    match (e)
    {
        | <[ $e: string ]> => WriteLine($"$e is a string literal");
        | <[ $e is int ]> => WriteLine($"$e is a double literal");
        | <[ {.. $expressions} ]> => WriteLine($"a sequence of expressions: $expressions");
        | _ => WriteLine("unknown expression");
    }
    <[ () ]>
}

проверяем:

determine_type(5);
determine_type("asdf");
def x = 10;
determine_type(x);
determine_type( { WriteLine("cool"); WriteLine("beer"); } );

не работает (пишет мол unknown expression)

Здравствуйте, PhantomIvan, Вы писали:

PI>не работает (пишет мол unknown expression)

что-то я протормозил, надо так:

        | <[ $(e: string) ]> => WriteLine($"$e is a string literal");
        | <[ $(e: int) ]> => WriteLine($"$e is a double literal");

в недрах топика про макросы нашёл

вот я макрос написал, отладил:

macro rotate(x, y, r)
{
    WriteLine($"Rotating ($x; $y), for $r radians");
    mutable (x', y', cos, sin) = (<[ $x ]>, <[ $y ]>, <[ Cos($r) ]>, <[ Sin($r) ]>);
    def lift(e)
    {
        | <[ $(d: double) ]> => <[ $(d: double) ]>
        | <[ $(i: int) ]> => <[ $(i: double) ]>
        | <[ $(f: float) ]> => <[ $(f: double) ]>
        | _ => e
    }
    def inline(z)
    {
        | <[ $(d: double) ]> => <[ $(d: double) ]>
        | _ => z
    }
    x' = inline(lift(x'));
    y' = inline(lift(y'));
    match (lift(r))
    {
        | <[ $(d: double) ]> =>
            cos = <[ $(Cos(d): double) ]>;
            sin = <[ $(Sin(d): double) ]>;
        | _ => ()
    }
    def inline(default, left, right, f) {
        match ((left, right))
        {
            | (<[ $(a: double) ]>, <[ $(b: double) ]>) => <[ $(f(a, b): double) ]>
            | _ => default
        }
    }
    mutable (xc, ys, xs, yc) = (<[ $x' * $cos ]>, <[ $y' * $sin ]>, <[ $x' * $sin ]>, <[ $y' * $cos ]>);
    def mul = { (a, b) => a * b };
    xc = inline(xc, x', cos, mul);
    ys = inline(ys, y', sin, mul);
    xs = inline(xs, x', sin, mul);
    yc = inline(yc, y', cos, mul);
    mutable (first, second) = (<[ $xc + $ys ]>, <[ $yc - $xs ]>);
    def add = { (a, b) => a + b };
    def sub = { (a, b) => a - b };
    first = inline(first, xc, ys, add);
    second = inline(second, yc, xs, sub);
    def result = <[ ($first, $second) ]>;
    <[ $result ]>
}

не пугайтесь, он всего лишь поворачивает вектор в компайл-тайме
(это упражнение с сайта немерле)

я вот думаю, а можно ли упростить в каком-нибудь месте? подкиньте предложение...

кстати, ихний эвалуатор что-то совсем не просто переписывать для общего случая, когда не только литералы, а еще и переменные входят в выражение...