Здравствуйте, calc.exe, Вы писали:
CE>А сколько людей на данный момент вообще знают о pattern matching? Через некоторое время — да, синтаксис станет "естественным". А пока может быть самое время сделать его оптимально удобным. (А where в ПМ, насколько я помню, вообще ввел VladD2 — тут говорить о "традициях" вообще смешно.)
Знают или узнают изучающие все функциональные языки, начиная от МЛ до хаскеля. Насколько я знаю where ввел не Влад, это появилось раньше, по крайней мере он рад был вообще от него отказаться, чем я и помог. Все же вы не ответили на вопрос что вам мешает использовать единый синтаксис для вариантов и классов:
def a : object = GetObject();
match (a)
{
| A.B(f) => // матч если переменная имеет подвариант A.B и получаем поле f
| A(field = f) => // совпало если просто A, получаем значение поля field в переменную f
| MyClass(field = f) => // получаем также поле f из класса типа MyClass если переменная этого типа, аналогично варианту
//| MyClass where (field = f) => // старый синтаксис довольно громоздкий, по типу класса
| MyClass @ (field = f) => // совсем не упрощает синтаксис
}
Вроде я предложил вариант короче, и он уже принят Владом, изменения в мастере, что мешает пользоваться единообразным синтаксисом, конструктор как у варианта в паттерне конструктор, попробуйте и оцените, может не так уж неудобно и выразите ваше мнение.
Здравствуйте, CodingUnit, Вы писали:
CU>Вроде я предложил вариант короче, и он уже принят Владом, изменения в мастере, что мешает пользоваться единообразным синтаксисом, конструктор как у варианта в паттерне конструктор, попробуйте и оцените, может не так уж неудобно и выразите ваше мнение.
Здравствуйте, Аноним, Вы писали:
А>а вот это правильно? f можно привести к выставленному типу? А>
А>public variant V
А> | A
А> r : string
А> s : double
А> | B
А> z : int
А> class C
А> public this()
А> mutable f: V
А> match(f)
А> | V.A => _ = f.r
А>
здесь обычные правила действуют, свое намерение компилятору надо указать явно, иначе он будет смотреть за переменной f в области видимости, которая есть f : V. Откуда он знает что вы хотите работать с экземпляром V или V.A это все таки приведение и оно требует накладных расходов. Для этого делается обычно:
public this()
{
def f : V;
match (f)
{
| V.A as f => _ = f.r
}
}
так делается во всех мне известных функциональных языках, это as pattern, как видите здесь могут быть очень сложные паттерны, в языке нет распознавания простой или сложный просто каждый паттерн обрабатывается по какому то принципу, например:
def tuple = (V.A("", 1), V.B(0))
match (tupl)
{
| (V.A, V.B) => // непонятно нужно ли что то приводить здесь фигурирует такой же паттерн что и выше
}
match (obj)
{
| ComplexType(Part(0), Part2(Some(a))) => // тот же паттерн и что тут приводить не ясно, надо указать явно
| ComplexType(Part(0), Part2(Some(a) as p)) as t => //
}
Вообщем автоматическое приведение тут не очень хорошо.