public macro SomeMacro(start, end)
    {        
        match( start, end )
        {
            | (_ is int, _ is int ) => <[]>
            | _ => Message.FatalError("")
        }                  
    
    }

public macro SomeMacro(start : int, end)

macro f(x)
{
  <[ _ = $x : int ]>
}

macro f (x)
{
 <[ 
   { _ = $x : int; //x приводится к int
    mutable y; 
    _ = y == $x; //тип y теперь совпадает с типом x, чистый хак =)
    y = 1 : int; //int приводится к x
   }
 ]>
}

macro test( lhs, rhs )
{
   match( lhs, rhs )
   {
      | ( <[$lhs is bla-bla-bla ]>, <[$rhs is bla-bla-bla ]> ) => <[]> //это нет
      | _ => <[]>
   }

   match( lhs, rhs )
   {
      | <[$lhs is bla-bla-bla ]> => <[]> //а это - да
      | _ => <[]>
   }
}

macro @forEx (expr, step, body)
syntax ("forEx", "(", expr, Optional ("step", step), ")", body) 
{
    def step = if (step == null) <[ 1 ]> else step;
    
    match (expr)
    {
        | <[ $firstExpr <  $maxExpr ]> with gt2 = true
        | <[ $firstExpr <= $maxExpr ]> with gt2 = false => 
            match (firstExpr)
            {
                | <[ $minExpr <  $i ]> with gt1 = true
                | <[ $minExpr <= $i ]> with gt1 = false =>
                    def gt1 = gt1;
                    def gt2 = gt2;
                    match (gt1, gt2)
                    {
                        | (false, false) => <[ for (mutable $i = $minExpr;     $i <= $maxExpr; $i += $step) $body ]>
                        | (true,  false) => <[ for (mutable $i = $minExpr + 1; $i <= $maxExpr; $i += $step) $body ]>
                        | (false, true)  => <[ for (mutable $i = $minExpr + 1; $i <  $maxExpr; $i += $step) $body ]>
                        | (true,  true)  => <[ for (mutable $i = $minExpr;     $i <  $maxExpr; $i += $step) $body ]>
                    }
                    
                | _ => Message.Error(expr.Location, $"Syntax error '$expr'"); <[ () ]>
            }

        | _ => Message.Error(expr.Location, $"Syntax error '$expr'"); <[ () ]>
        
    }

forEx (0 <= i < 10 step 2)
    forEx (0 <= k <= 2)
        WriteLine($"i=$i  k=$k");

КЛ>macro test( lhs, rhs )
КЛ>{
КЛ>   match( lhs, rhs )
КЛ>   {
КЛ>      | ( <[$lhs is bla-bla-bla ]>, <[$rhs is bla-bla-bla ]> ) => <[]> // это попытка возвратить пустоту
КЛ>      | _ => <[]>
КЛ>   } // причем значение не испоьзуется. match в дамнном случае выражение!

КЛ>   match( lhs, rhs )
КЛ>   {
КЛ>      | <[$lhs is bla-bla-bla ]> => <[]> // и здесь ерунда.
КЛ>      | _ => <[]>
КЛ>   }
КЛ>}
КЛ>

namespace MacroLibrary1
{
    public macro MyTestMacro(start, end, body)
    syntax ("from", start, "to", end, body)
    {                
        def typer = Nemerle.Macros.ImplicitCTX() : Nemerle.Compiler.Typer;        
        def ts = typer.TypeExpr(start);        
        def te = typer.TypeExpr(end);        
        
        //KL: for help
        //def ts = typer.TypeExpr(start) : Nemerle.Compiler.Typedtree.TExpr;        
        //def tyVar = ts.Type : Nemerle.Compiler.TyVar;
        //def hint = tyVar.Hint : option[MType];        
        //def startTypeInfo = hint.Value.TypeInfo;        
        //def endTypeInfo = typer.TypeExpr(end).Type.Hint.Value.TypeInfo;
        //def endType = endTypeInfo.SystemType;
        
        typer.DelayMacro( fun (fail_loud)
        {
            match (ts.Type.Hint, te.Type.Hint)
            {
                | (Some(Nemerle.Compiler.MType.Class(cs, _)), Some(Nemerle.Compiler.MType.Class(ce, _)))
                        when( !cs.IsValueType && !ce.IsValueType ) =>
                        when (fail_loud) 
                            Message.Error (start.Location, $"'$start, $end' is not a reference type as required by the lock expression");                        
                        None()              
                | (None, _) => when (fail_loud)
                                Message.Error (start.Location, "compiler was unable to analyze type start,end");
                            None()
                            
                | (_, None) => when (fail_loud)
                                Message.Error (start.Location, "compiler was unable to analyze type start,end");
                            None()
                            
                | _ => 
                
                def startType = ts.Type.Hint.Value.TypeInfo.SystemType;
                def endType = te.Type.Hint.Value.TypeInfo.SystemType;                            
                        
                when( startType.Equals(typeof(int)) && endType.Equals(typeof(int)) )                
                {
                    def result =                 
                
                        <[
                            when( $start >= $end ) throw System.ArgumentException();
                
                            for (mutable var = $start; var <= $end; var++)
                            {
                                $body
                            }        
                        ]>;
                    
                    Nemerle.Imperative.Return( Some( result ) );
                }
                
                Message.Error (start.Location, "start & end must be System.Int32");
                None()
            }
        });
    }
}

module Program
{
        Main() : void
    {                    
        def a = [1,2];    
        def    func() { 10; };
        
        from 1 to 10 //ok
        {
            WriteLine("Hi!");
        }

                def i = 10;

            from 1 to i //ok
        {
            WriteLine("Hi!");
        }

            from 1 to a //Errors: start & end must be System.Int32; typing fails on delayed macro
        {
            WriteLine("Hi!");
        }

            from 1 to func //internal compiler error: got some unknown exception of type System.NullReferenceException
        {
            WriteLine("Hi!");
        }
            from 1 to func() //ok
        {
            WriteLine("Hi!");
        }

        }
}

macro @forEx (expr, step, body)
syntax ("forEx", "(", expr, Optional ("step", step), ")", body) 
{
    def step = if (step == null) <[ 1 ]> else step;
    
    match (expr)
    {
    | <[ $minExpr <= $i <= $maxExpr ]> => <[ for (mutable $i = $minExpr;     $i <= $maxExpr; $i += $step) $body ]>
    | <[ $minExpr <  $i <= $maxExpr ]> => <[ for (mutable $i = $minExpr + 1; $i <= $maxExpr; $i += $step) $body ]>
    | <[ $minExpr <  $i <  $maxExpr ]> => <[ for (mutable $i = $minExpr + 1; $i <  $maxExpr; $i += $step) $body ]>
    | <[ $minExpr <= $i <  $maxExpr ]> => <[ for (mutable $i = $minExpr;     $i <  $maxExpr; $i += $step) $body ]>
    | _ => Message.Error(expr.Location, $"Syntax error '$expr'"); <[ () ]>
    }
}

                    def gt1 = gt1;
                    def gt2 = gt2;

(false, false)
(true,  false)
(true,  true) 
(false, true)

$minExpr;    
$minExpr + 1;
$minExpr;
$minExpr + 1;

VD>>Потому что как ты хочешь не работает. Можно сказать — баг.

WH>Гм. А у меня работат.

Если ваша программа заработала с первого раза, обратитесь к системному программисту — он исправит ошибку в компиляторе.