Никак не хочет компилировать следующий код.

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

module Program
{
  Main() : void
  {
    variant A
    {
     | B
     | C
    }
   
    WriteLine("Hi!");
  }
}

выдает ошибки:
Error: parse error near keyword 'variant': unexpected keyword in expression context
Error: expected ';'
Error: parse error near identifier 'A': unexpected token after expression in sequence

все относится к строке 9 ( variant A )

Компилирую в Nemerle Studio интегрированной в VS 2008 shell

Подскажите чем вызвана ошибка.

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

JеS>Подскажите чем вызвана ошибка.

Типы нельзя объявлять внутри функций и методов.

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

JеS>Подскажите чем вызвана ошибка.

Компилятор ведь жалуется: unexpected keyword in expression context.

Вариант — это вроде как класс. Его нет смысла определять внутри метода. Вынесите определение за код метода:

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

 module Program
 {
  variant A
  {
  | B
  | C
  } 

  Main() : void
   {
     
   
     WriteLine("Hi!");
   }
 }

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

H>Типы нельзя объявлять внутри функций и методов.

Изначально код выглядел так:

using System.Console;

def readInput()
{
  def result = ReadLine();
  
  unless (result == "")
  {
    WriteLine("Вы ввели:");
    WriteLine(result);
    readInput();
  }
}

readInput();

variant Token
{
  | Number
  | Operator
  | Error
}

def lexer(text : string) : list[Token]
{
  mutable index = 0;

  def peek() : char
  {
    if (index >= text.lenght ) '\0' 
      else text[index]
  }

  def read() : char
  {
    def ch = peek();
    
    when(index < text.lenght)
      index++
    ch;
   }
   
   def isDegit(ch) { ch >= '0' && ch <= '9' }
   
   def loop(resultTokens : list[Token]) : list[Token]
   {
     def errror()
     {
       WriteLine(string(' ',index - 1) + "^");
       WriteLine("Errror.You may entered digit or operator!");
       (Token.Error() :: resultTokens).Reverse()
     }
     
     def number(ch : char, accamulator : int = 0) : int
     {
       def hightOrderValue   = accamulator * 10;
       def currentOrderValue = ch - '0' : int;
       def currentValue      = currentOrderValue + hightOrderValue;
       
       if(isDigit(peek()))
         number(read(), currentValue);
       else
         currentValue
     }
       
     def ch = read();
     
     match(ch)
     {
       | ' ' | '\t'            => loop(resultTokens)
       | '+' | '-' | '*' | '/' => loop(Token.Operator(ch.ToString()) :: resultTokens)
       | '\0'                  => resultTokens.Reverse()
       | _ when isDigit(ch)    => loop(Token.Number(number(ch)) :: resultTokens)
       | _                     => error()
     }
   }
   loop([]);
 }

Он взят из RSDN Magazine (2009 год 3 выпуск статья "Язык Nemerle.Часть 2")

ошибки те же самые.

Это сокрашённая нотация для метода Main. Так что, ошибки тействительно те же самые. Правильно будет написать:

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

variant A
{
 | B
 | C
}

module Program
{  Main() : void
  {
    WriteLine("Hi!");
  }
}

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

DR>Это сокрашённая нотация для метода Main. Так что, ошибки тействительно те же самые. Правильно будет написать:

DR>

DR>using System;
DR>using System.Console;
DR>using Nemerle.Utility;

DR>variant A
DR>{
DR> | B
DR> | C
DR>}

DR>module Program
DR>{  Main() : void
DR>  {
DR>    WriteLine("Hi!");
DR>  }
DR>}
DR>

фууух,все разобрался.Работает)

Спасибо всем большое)