Такая проблема: компилятор не даёт возможности писать названия опций варианта русскими буквами.

    variant Вариант
    {
        | Вариант1
        | Вариант2
    }

Сообщение об ошибке:
Error: variant options' names must start with capital letter

То есть получается, что если первый символ не попадает в диапазон [A-Z], то буква считается строчной и выдаётся ошибка. Не совсем понятно накладываеое ограничение: почему название опции не может начинаться со строчной буквы? Может избавится то него? Ведь никто не ограничивает способы наименования классов.

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

D>Сообщение об ошибке:
D>Error: variant options' names must start with capital letter

Баг. Я его уже поправил (у себя) но залить пока не могу, так как немерловый сайт опять лежит.

Если компилировался с исходников, то надо в файле ncc/parsing/Utility.n заменить функцию is_capitalized на:

    public is_capitalized (s : string) : bool
    {
      def idx = s.LastIndexOf('.');
      char.IsUpper(s[idx + 1])
    }

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

VD>Баг. Я его уже поправил (у себя) но залить пока не могу, так как немерловый сайт опять лежит.

VD>Если компилировался с исходников, то надо в файле ncc/parsing/Utility.n заменить функцию is_capitalized на:
VD>

VD>    public is_capitalized (s : string) : bool
VD>    {
VD>      def idx = s.LastIndexOf('.');
VD>      char.IsUpper(s[idx + 1])
VD>    }
VD>

окей, спасибо Влад

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


D>Не совсем понятно накладываеое ограничение: почему название опции не может начинаться со строчной буквы? Может избавится то него? Ведь никто не ограничивает способы наименования классов.

Потому что у тебя тогда сломается паттерн-мэтчинг по ним.

variant Var
{
  | AClass { fieldA : int}
  | BClass { fieldB : string}
}

module Program
{
  Main() : void
  {
    Process(Var.AClass(42));
    Process(Var.BClass("test"));
    Process(null);
    _ = Read();
  }
  
  Process(obj : Var) : void
  {
    | AClass(a) => WriteLine(a) // паттерн "Конструктор"
    | bClass => WriteLine(bClass) // паттерн "Переменная". Чтобы ни было значением параметра obj, связывается с именем bClass.
                                      // В данном случае выведется имя типа, Var+BClass, потому что не переопределен ToString()
    | _ => WriteLine("not recognized");
  }
}

С обычными классами ты не можешь использовать паттерн "Конструктор", поэтому на них ограничений и не накладывается.

Здравствуйте, Сергей Туленцев, Вы писали:

СТ>С обычными классами ты не можешь использовать паттерн "Конструктор", поэтому на них ограничений и не накладывается.

Не согласен: компилятор ведь вполне может различить 2 типа паттернов.
Например:

    | Var.BClass(b) => WriteLine(b) // паттерн "Конструктор"
    | BClass => WriteLine(BClass) // паттерн "Переменная".

Или так, если у опции BClass нет полей:

    | Var.BClass() => WriteLine("123") // паттерн "Конструктор"
    | BClass => WriteLine(BClass) // паттерн "Переменная".

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

D>Здравствуйте, Сергей Туленцев, Вы писали:

СТ>>С обычными классами ты не можешь использовать паттерн "Конструктор", поэтому на них ограничений и не накладывается.

D>Не согласен: компилятор ведь вполне может различить 2 типа паттернов.
D>Например:
D>

D>    | Var.BClass(b) => WriteLine(b) // паттерн "Конструктор"
D>    | BClass => WriteLine(BClass) // паттерн "Переменная".
D>

D>Или так, если у опции BClass нет полей:
D>

D>    | Var.BClass() => WriteLine("123") // паттерн "Конструктор"
D>    | BClass => WriteLine(BClass) // паттерн "Переменная".
D>

Нууу, может и получится так сделать, вот только:
а) вряд ли кто этим будет заниматься
б) Поломает весь существующий код, в том числе и самого компилятора
в) выглядит более громоздко
г) подавляющему большинству людей не надо (неужели кто-то еще называет классы с маленькой буквы?)

Здравствуйте, Сергей Туленцев, Вы писали:

СТ>Нууу, может и получится так сделать, вот только:
СТ>а) вряд ли кто этим будет заниматься

Самый сильный аргумент

СТ>б) Поломает весь существующий код, в том числе и самого компилятора

Нет. Ведь в данном случае речь идёт исключительно о расширении возможностей.

СТ>в) выглядит более громоздко

Так можно префикс Var и не добавлять. Компилятор запросто может увидеть наличие скобок.

    | BClass() => WriteLine("123") // паттерн "Конструктор"
    | BClass => WriteLine(BClass) // паттерн "Переменная".

СТ>г) подавляющему большинству людей не надо (неужели кто-то еще называет классы с маленькой буквы?)

Согласен. Паскаль нотация для классов — стандарт де факто. Вот только не очень приятно, что современный язык использует нотацию для идентификации типов как какой нибудь древний Фортран. Очень смахивает на хакерский трюк. Несолидно.

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

СТ>>б) Поломает весь существующий код, в том числе и самого компилятора
D>Нет. Ведь в данном случае речь идёт исключительно о расширении возможностей.
Ну, как минимум придется скобки везде дописывать, не так ли? Стало быть, поломает.

D>Согласен. Паскаль нотация для классов — стандарт де факто. Вот только не очень приятно, что современный язык использует нотацию для идентификации типов как какой нибудь древний Фортран. Очень смахивает на хакерский трюк. Несолидно.
Солидно, несолидно... Зато тут есть мощный паттерн-мэтчинг. А вот в каком-нибудь сишарпе его нет, равно как и ограничений на имена вариантов, которых там тоже, впрочем, нет.
Лично я готов мириться с такой несолидностью.

Здравствуйте, Сергей Туленцев, Вы писали:

СТ>Здравствуйте, Dufrenite, Вы писали:

СТ>>>б) Поломает весь существующий код, в том числе и самого компилятора
D>>Нет. Ведь в данном случае речь идёт исключительно о расширении возможностей.
СТ>Ну, как минимум придется скобки везде дописывать, не так ли? Стало быть, поломает.

Точно. Только сейчас проверил. Можно и без скобок писать . Сильно извиняюсь .

D>>Согласен. Паскаль нотация для классов — стандарт де факто. Вот только не очень приятно, что современный язык использует нотацию для идентификации типов как какой нибудь древний Фортран. Очень смахивает на хакерский трюк. Несолидно.
СТ>Солидно, несолидно... Зато тут есть мощный паттерн-мэтчинг. А вот в каком-нибудь сишарпе его нет, равно как и ограничений на имена вариантов, которых там тоже, впрочем, нет.
СТ>Лично я готов мириться с такой несолидностью.