macro for(init, cond, change, body) 
syntax ("for", "(", init, ";", cond, ";", change, ")", body) 
{ 
  ... 
}

    macro forAll(j, j0, je, body)
    syntax("forAll", j, "=", "[", j0, ";", je, "]", body)
    {
        for(mutable j = j0; j <= je; j++)
        {
            body;
        }
    }

FDS>>    macro forAll(j, j0, je, body)
FDS>>    syntax("forAll", j, "=", "[", j0, ";", je, "]", body)
FDS>>    {
FDS>>        for(mutable j = j0; j <= je; j++)
FDS>>        {
FDS>>            body;
FDS>>        }
FDS>>    }
FDS>>

macro @forAll(j, j0, je, body)
    syntax("forAll", j, "=", "[", j0, ";", je, "]", body)
{ 

    def typer = Macros.ImplicitCTX ();
    
    def tj  = typer.TypeExpr(j);
    def tj0 = typer.TypeExpr(j0);
    def tje = typer.TypeExpr(je);
    
    def k = Nemerle.Macros.Symbol (Util.tmpname ("forAll_"));
    
    if (tj.Type.Require (<[ ttype: int ]>)/*tj.Type == <[ ttype: int ]> &&  tj0.Type == <[ ttype: int ]> && tje.Type == <[ ttype: int ]>*/)
    {
    <[
      for (mutable $(k: name) = $j0; $(k: name) <= $je; $(k: name)++)
      {
        body
      }
    ]>
    }
    else 
    {
        Message.Error("'forAll' j, j0, je must have type int, while it has $(tj.Type.ToString()),  $(tj0.Type.ToString()), $(tje.Type.ToString())");
        <[ () ]>
    }
}
}

  macro @while (cond, body)
  syntax ("while", "(", cond, ")", body) 
  {
    def loop = Nemerle.Macros.Symbol (Util.tmpname ("while_"));

    <[ 
      $("_N_break" : global) : {
        def $(loop : name) () : void {
          when ($cond) {
            $("_N_continue" : global) : {
              $body 
            } 
            $(loop : name) ()
          }
        } 
        $(loop : name) (); 
      }
    ]>
  }

---------------------------
Assertion Failed: Abort=Quit, Retry=Debug, Ignore=Continue
---------------------------






    at NemerleLanguageService.Check(ParseRequest request)  

    at NemerleLanguageService.ParseSource(ParseRequest request)  

    at LanguageService.ParseRequest(ParseRequest req)  

    at LanguageService.ParseThread()  

    at ThreadHelper.ThreadStart_Context(Object state)  

    at ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)  

    at ThreadHelper.ThreadStart()  


---------------------------
Прервать   Повтор   Пропустить   
---------------------------

if (tj.Type.Require (<[ ttype: mutable int ]>)

Error    10    Internal compiler error, please report a bug to bugs.nemerle.org. You can try modifying program near this location.    F:\Prg\BarCalculator\Current\BarsCalculator\CalcProcessor\CalcProcessor.n    26    30    CalcProcessor

using Nemerle.Compiler;


namespace Nemerle.Core
{
  macro @range (var : parameter, begin, end, body)
  syntax ("range", var, "in", "[", begin, ";", end, "]", body) 
  {
      match (var)
      {
          | <[ parameter : $(iname : name) : $ty ]> => 
              <[
                  for ($(iname : name) = $begin; $(iname : name) <= $end; $(iname : name)++)
                  {
                      $body
                  }
              ]>
          | _ =>
            Message.FatalError ("expected a single parameter for the range operator");
      }
  }
}

using System;
using System.Console;

module Program
{
  Main() : void
  {
    mutable i : int;

    range i in [5; 7]
    {
        WriteLine($"$i");
    }

    ReadKey();
  }
}

using System;
using System.Console;
using Nemerle.Utility;
using Nemerle.Compiler;

namespace VV
{
  macro @range (var : parameter, begin, end, body)
  syntax ("range", var, "in", "[", begin, ";", end, "]", body) 
  {
      match (var)
      {
          | <[ parameter : $(iname : name) : $ty ]> => 
              <[
                  for ($(iname : name) = $begin; $(iname : name) <= $end; $(iname : name)++)
                  {
                      $body
                  }
              ]>
          | _ =>
            Message.FatalError ("expected a single parameter for the range operator");
      }
  }

module Program
{
  Main() : void
  {
    mutable i : int;

    range i in [5; 7]
    {
        WriteLine($"$i");
    }
 
    
    _ = Console.ReadLine();
  }
}

}

Error    1    expected ';'. Parse error near identifier 'i': unexpected token after expression in sequence
    F:\Prg\tmp\070524\NilListCheck\Main.n    53    8    NilListCheck
Error    2    unbound name 'range'    F:\Prg\tmp\070524\NilListCheck\Main.n    53    2    NilListCheck
Error    3    expected `;'    F:\Prg\tmp\070524\NilListCheck\Main.n    53    9    NilListCheck
Error    4    parse error near identifier `i': unexpected token after expression in sequence    
F:\Prg\tmp\070524\NilListCheck\Main.n    53    9    NilListCheck

//a.n
using Nemerle.Compiler;

namespace MyMacros
{
  macro @range (var, begin, end, body)
  syntax ("range", var, "_in_", "[", begin, ";", end, "]", body) 
  {
    <[
      for (mutable $var = $begin; $var <= $end; $var++)
      {
        $body
      }
    ]>
  }
}

// b.n
using System;
using System.Console;
using MyMacros;

module Program
{
  Main() : void
  {
    range i _in_ [5; 7]
    {
        WriteLine($"$i");
    }
  }
}

  macro @range (var : parameter, begin, end, body)
  syntax ("range", var, "in", "[", begin, ";", end, "]", body) 
  {
      match (var)
      {
          | <[ parameter : $(iname : name) : $ty ]> =>
             <[
                 mutable $(iname : name) : int;
                  for ($(iname : name) = $begin; $(iname : name) <= $end; $(iname : name)++)
                  {
                      $body
                  }
              ]>
          | _ =>
              Message.FatalError ("expected a single parameter for the range operator");
      }
  }

K>  macro @range (var : parameter, begin, end, body)
K>  syntax ("range", var, "in", "[", begin, ";", end, "]", body) 
K>  {
K>      match (var)
K>      {
K>          | <[ parameter : $(iname : name) : $ty ]> =>
K>             <[
K>                 mutable $(iname : name) : int;
K>                  for ($(iname : name) = $begin; $(iname : name) <= $end; $(iname : name)++)
K>                  {
K>                      $body
K>                  }
K>              ]>
K>          | _ =>
K>              Message.FatalError ("expected a single parameter for the range operator");
K>      }
K>  }
K>

K>  macro @range (var : parameter, begin, end, body)



| <[ parameter : $(iname : name) : $ty ]> =>

Message.FatalError ("expected a single parameter for the range operator");

    range i in [5; 7]
    {
        WriteLine($"$i");
    }
 
 
    range i in [3; 6]
    {
        WriteLine($"$i");
    }

K>>>  macro @range (var : parameter, begin, end, body)


FDS>>| <[ parameter : $(iname : name) : $ty ]> =>
FDS>>

K>Вкратце, это для того первоначального моего варианта, когда я принимал переменную как параметр. И вообще, забудь про мой пример, он неправильный Смотри на пример приведенный ie, красивое и правильное решение.

FDS>>Message.FatalError ("expected a single parameter for the range operator");
FDS>>

ie>namespace MyMacros
ie>{
ie>  macro @range (var, begin, end, body)
ie>  syntax ("range", var, "_in_", "[", begin, ";", end, "]", body) 
ie>  {
ie>    <[
ie>      for (mutable $var = $begin; $var <= $end; $var++)
ie>      {
ie>        $body
ie>      }
ie>    ]>
ie>  }
ie>}
ie>

  macro @range (varI, begin, end, body)
  syntax ("range", varI, "[", begin, ";", end, "]", body) 
  {
    
     match(varI)
     {
         | <[ $(var : name) = $empty ]> => <[
      for (mutable $var = $begin; $var <= $end; $var++)
      {
        $body
      }
    ]>
         | _ => Message.FatalError ("expected a single parameter for the range operator");
     }
  }

def x = 5;
def x = 10;

FDS>    range i in [5; 7]
FDS>    {
FDS>        WriteLine($"$i");
FDS>    }
 
 
FDS>    range i in [3; 6]
FDS>    {
FDS>        WriteLine($"$i");
FDS>    }
FDS>

{
  mutable x = ...; // в одной области видимости
    ...
}
{
  mutable x = ...; // в другой области видимости
    ...
}

<[ $("someName" : usesite) = 0; ]>

WriteLine($"Для i = $i из диапазона... бла бла");