class x
{
    public fld1 : int;
    // public fld2 : int;
}

main() : void
{
    def xx = x();
    def fld2 = 5;
    match (xx)
    {
        | x() => 
            something = fld2; // если добавить поле fld2 в класс x, то присвоено будет совсем другое значение
                              // И понять это можно только если точно знать, что в классе есть поле с таким именем
    }
}

match(var)
{
  x =>
  x() =>
}

match(var)
{
  x => //x - тип, в этой ветке здесь var вводится как приведенное к x
        var.fld_x

  x() => //то же что выше + вводятся все открытые поля x
         //т. е. если у x есть fld1, fld2, то сразу можно написать
         methodn(fld1, fld2)
}

match (obj.GetSomeVal(abc))
{
  | Abc([])                      => // работаем с типом у которого параметр пустой список
  | x when (x.CheckValue() == 3) => // работаем с переменной, если значение метода какое нужно
  | Abc(_ :: _ as lst) as x      => // также работаем с переменной и получаем список из Abc и матчим по типу
  | x                            => // просто работаем с переменной очень сокращает результат функции
}

match (a)
{
  | p when p > 10 => ()
  | p => ()
}

match (a)
{
  | _ as p when p > 10 => ()
  | _ as p => ()
}

match (1)
{
  | _ => System.Console.WriteLine(_); // Error :?
}

match(var)
{
  x => //x - тип, в этой ветке здесь var вводится как приведенное к x
        var.fld_x

  x() => //то же что выше + вводятся все открытые поля x
         //т. е. если у x есть fld1, fld2, то сразу можно написать
         methodn(fld1, fld2)
}

match(method(n))
{
  x => //x - тип

  x as var => x - тип, var - значение

  x() => // вводятся все открытые поля результата method(n)
         //т. е. если у него есть fld1, fld2, то сразу можно написать
         methodn(fld1, fld2)

  _ as var => используем var

  _ => как обычно
}

| _ => lst.FoldLeft([], fold_func(a, _, _, _))

type Color =
    | red

error FS0053: Discriminated union cases and exception labels must be uppercase identifiers

  | :? point as p ->  // для динамического определения типа
  | {field = f}   ->  // для распознавания рекорд паттерна
  | x             ->  // просто переменная

| x when (x.IsSomeOne()) => x
| x when (x.IsSomeTwo()) => x

| A =>
| x =>

match (lst)
{
 | []  => // пустой список
 | lst => // список но не пустой, и работаем с ним, это очень частый случай, уж никто не будет здесь ожидать типа, поверь мне на слово
}

| x() as y => methodn(y.fld1, y.fld2)

match (var)
{ 
  | *x => // наподобие разъименования указателя в С++
  | &x => // наподобие взятия адреса в С++
  | @x => // monkey type
  | :? x => // как в фшарп тест типа
}

CU>match (var)
CU>{ 
CU>  | *x => // наподобие разъименования указателя в С++
CU>  | &x => // наподобие взятия адреса в С++
CU>  | @x => // monkey type
CU>  | :? x => // как в фшарп тест типа
CU>}
CU>

look_into(obj); // после этого ниже видно все содержимое obj, включая поля, свойства методы и их можно вызывать без объекта

func(field1);
WriteLine(Method());

look_into(obj)
{
 func(field1);
 WriteLine(Method());
}

look_obj match (obj)
{
 | x() => // здесь получаете содержимое x
}

look_obj match (obj)
{
 | x() => Use(field1, Method2()) // здесь field1 и Method2 принадлежат объекту, но неоднозначности надо отслеживать
}

// макросом надо переписать в такой:

match (obj)
{
 | x as id => Use(id.field1, id.Method2()) // здесь field1 и Method2 принадлежат объекту, но неоднозначности надо отслеживать
}

| x            => // переменная
| x()          => // может быть класс
| x(a, b)      => // все основные паттерны работают с типом нач.нам маленькую букву
| x(field = a) =>
| x as var     =>
| var is x     =>

// уже устал одно и тоже везде писать
| x   => // переменная
| x() => // пожалуйста используйте тип с маленькой буквы, только покажите скобками
| SomeEnum.a => // тоже подойдет если у вас перечисление