Пытаюсь скомпилировать код калькулятора в версии 1.690
(в 1.686 работало)
получаю ошибку на

  [PegGrammar(Options = EmitDebugSources, start, grammar  
        {

Error 18 expected `;' D:\Distr\Docs\NET\Nemerle\Статья 3 Calc\CalcPeg\Calculator.n 25 10 CalcPeg-VS_2008

Error 19 parse error near `{...}' group: unexpected token after expression in sequence (you forget a closing bracket?). D:\Distr\Docs\NET\Nemerle\Статья 3 Calc\CalcPeg\Calculator.n 25 10 CalcPeg-VS_2008



Код калькулятора

namespace Calculator
{
  type LoopTokens = NToken * NToken * int;
  
  [Record] 
  public class ParserFatalError : Exception
  {
    public Pos : int;
  }
  
  /// <summary>
  /// Парсер
  /// </summary>  
  [PegGrammar(Options = EmitDebugSources, start, grammar  
        {
        any                   = ['\u0000'..'\uFFFF']; // распознают любой символ
        digit                 = ['0'..'9']+; // распознает число 
        spaces                = (' ' / '\t')*; // распознает пробельные сивоволы
        
        num                   : int = digit spaces;
        unaryMinus            : int = '-' spaces simplExpr;
        unaryEq               : int = '=' spaces unaryMinus;
        parenthesesExpr       : int = '(' spaces sumOrSub ')' spaces;
        parenthesesExprError  : int = '(' spaces sumOrSub (any / any);
        simplExpr             : int = num / parenthesesExpr / unaryEq 
                                      / parenthesesExprError / simplExprError;
        simplExprError        : int = any;
        inputError            : int = any;
        mulOrDiv              : int = simplExpr (('*' / '/') spaces simplExpr)*;
        sumOrSub              : int = mulOrDiv  (('+' / '-') spaces mulOrDiv )*;
        mainRule              : int = sumOrSub inputError?;
        start                 : int = spaces mainRule !any;
    }
  )]
  public class CalcParser
  {      
    private num(digit : NToken, _ : NToken) : int
    {        
        int.Parse(GetText(digit)); //int.Parse(digit.EndPos);
    }
    
    private unaryEq(_ : NToken, _ : NToken, simplExpr : int) : int
    {
      simplExpr
    }
    
    private unaryMinus(_ : NToken, _ : NToken, simplExpr : int) : int
    {
      - simplExpr
    }
    
    private parenthesesExpr(_ : NToken, _ : NToken, simplExpr : int, 
                            _ : NToken, _ : NToken) : int
    {
      simplExpr
    }
    
    private parenthesesExprError(_ : NToken, _ : NToken, last : int, 
                                 _ : NToken) : int
    {
      throw ParserFatalError("Ожидается закрывающая скобка или "
        + "'+', '-', '*', '/', за которым следует число или выражение",
        last);
    }
    
    private inputError(tok : NToken) : int
    {
      throw ParserFatalError("Ожидается '+', '-', '*', '/', за которым "
        + "следует число или выражение", tok.StartPos);
    }
    
    private simplExprError(tok : NToken) : int
    {
      throw ParserFatalError("Ожидается число или выражение в скобках", 
        tok.StartPos);
    }
    
    private mainRule(expr : int, _ : option[int]) : int
    {
      expr
    }

    private simplExpr(expr : int) : int
    {
      expr
    }
    
    private start(_ : NToken, expr : int) : int
    {
        expr
    }
    
    private mulOrDiv(firstExpr : int, lst : List[LoopTokens]) : int
    {
      DoOpHelper(firstExpr, lst)
    }
    
    private sumOrSub(firstExpr : int, lst : List[LoopTokens]) : int
    { 
      DoOpHelper(firstExpr, lst)
    }
     
    private DoOpHelper(firstExpr : int, lst : List[LoopTokens]) : int
    {
      def doOp(x : int, y : int, op : string) : int
      {
        match (op)
        {
          | "*" => x * y
          | "/" => x / y
          | "+" => x + y
          | "-" => x - y
          | "%" => x % y
          | _   => assert(false);
        }
      }
           
      mutable r = firstExpr;
      
      foreach ((opTok, _, secondTok) in lst)
        r = doOp(r, secondTok, GetText(opTok));
    
      r  
    }
  }
}