class Test
{
  public field : int;
}

// старый синтаксис:
def func1(obj : Test)
{
 match (obj)
 {
   | Test where (field = f) => f
 }
}

// новый синтаксис (не отличается от вариантов):
def func2(obj : Test)
{
 match (obj)
 {
   | Test(field = f) => f
 }
}

internal IsDefaultValuePlaceHolder(expr : Expression) : bool
{
    | Member(null, member) when
        member.DeclaringType.IsGenericType &&
        member.Name == "Value" &&
        member.DeclaringType.GetGenericTypeDefinition() == typeof(DefaultValue[_])

    | _ is DefaultValueExpression => true
    | _ => false
}

internal IsDefaultValuePlaceHolder(expr : Expression) : bool
{
    | Member(null, (DeclaringType = (IsGenericType = true) as dt, Name = "Value")) when
        dt.GetGenericTypeDefinition() == typeof(DefaultValue[_])

    | _ is DefaultValueExpression => true
    | _ => false
}

[assembly: ExtensionPattern(Expression, Member2(expr, name, dectype) = MemberExpression where (Expression = expr, Member = (Name = name, DeclaringType = dectype)))]

internal IsDefaultValuePlaceHolder(expr : Expression) : bool
{
    | Member2(null, "Value", (IsGenericType = true) as dt) when
        dt.GetGenericTypeDefinition() == typeof(DefaultValue[_])

    | _ is DefaultValueExpression => true
    | _ => false
}

public class A
{
  public this(field : int) { this.field = field; }
  
  public field : int;
}

def a = A(10);

// Сопоставляется не конструктор, а поле. Это видно из "where"
def oldf = 
 match (a)
 {
   | A where (field = f) => f
 };

// Сопоставляется не конструктор, но с первого взгляда не ясно.
def newf = 
 match (a)
 {
   | A (field = f) => f
 };

_C_>с вариантами та же "проблема"

variant A
{
    | X { p : int; q : int }
}

def aa = A.X(1,1); 
match (aa)
{
    | A.X       (    pp,     qq) => ()
    | A.X       (p = pp, q = qq) => ()
    | A.X where (    pp,     qq) => ()
    | A.X where (p = pp, q = qq) => ()
    | _ => ()
}

class HasFields
{
    public this() {}
    
    public q : int;
    public p : int;
}

class HasProperties
{
    public this() {}
    
    public p : int{get;set;}
    public q : int{get;set;}
}

module PP
{
    Main() : void
    {
        // OK
        def hasFields = HasFields();
        match (hasFields)
        {
            | HasFields where (p = 1, q = 2) => ()
            | HasFields where (    1,     2) => ()
            | _ => ()
        }
        
        def hasProperties = HasProperties();
        match (hasProperties)
        {
            | HasProperties where (p = 1, q = 2) => ()
            | HasProperties where (    1,     2) => () // error : pattern matches 2 values, while the type `HasProperties' has 0 fields
            | _ => ()
        }
    }
}

variant A
{
 | A1
 | A2

 field : int;
}

def test = A.A1();
match (test)
{
 | A where (field = f) => f
}

match (test)
{
 | A(field = f) => f
}

CU>> match (obj)
CU>> {
CU>>   | Test() <- { field = f } => f
CU>> }
CU>>

| Test(field = f) => f

| Test(f) => f

class u
  public h: int = 5
  
module Program 
      
  Main() : void
    
    def g : object = u()        
    
    match(g)
      | u(h) => _ = h
      | _ => {}

class U
  public j: int = 5
  public h: int = 5
  
module Program 
      
  Main() : void
  
    def g : object = U()        
    
    match(g)
      | U(h) => _ = h
      | _ => {}

| Test where (field = f) => 
| Test() <- {field = f} => // на один символ короче where (не то за что стоит бороться)
| Test() <- {f, f2} => // как определить конструктор? такого синтаксиса нет
| Test(field = f)       =>

| Test(f)       =>

variant A
{
  | B
    {
      field : int;

      public this(a : int, b : int) {}
    }
 | 
}

    def test = A.B(1);
    match (test)
    {
      | A.B(1, 2) => ... // не скомпилируется
    }

| o       => // всегда матчит переменную, потому что с маленькой буквы
| o()     => // всегда матчит объект, потому что даны скобки
| o(a, b) => // тоже объект, потому что скобки и значения конструктора
| O       => // всегда объект потому что с большой буквы
| o as t  => // o - объект, потому что находится с левой стороны as
| t is o  => // o - объект, потому что справа is

CU>>| o       => // всегда матчит переменную, потому что с маленькой буквы
CU>>| o()     => // всегда матчит объект, потому что даны скобки
CU>>| o(a, b) => // тоже объект, потому что скобки и значения конструктора
CU>>| O       => // всегда объект потому что с большой буквы
CU>>| o as t  => // o - объект, потому что находится с левой стороны as
CU>>| t is o  => // o - объект, потому что справа is
CU>>

| o       => // матчит переменную и раньше и теперь просто присваивает значение объекта переменной
| o()     => // раньше из за регистра никак не хотел распознавать тип, присваивал переменной o, теперь матчит тип o
| o(a, b) => // раньше как ты писал он писал что вариант опция требуется, теперь полноценно распознает тип, потому что указаны скобки и значения 
| O       => // всегда тип потому что с большой буквы, большие буквы не пишутся для переменных здесь, хотя помоему там по старому определяется эвристика для поиска типа с данным именем
| o as t  => // o - тип, потому что находится с левой стороны as, раньше маленькой буквы не воспринимал и нуждался в большой букве для типа
| t is o  => // o - тип, потому что справа is, сейчас разрешает маленькую букву

CU>>| o       => // всегда матчит переменную, потому что с маленькой буквы
CU>>| o()     => // всегда матчит объект, потому что даны скобки
CU>>| o(a, b) => // тоже объект, потому что скобки и значения конструктора
CU>>| O       => // всегда объект потому что с большой буквы
CU>>| o as t  => // o - объект, потому что находится с левой стороны as
CU>>| t is o  => // o - объект, потому что справа is

CU>>

| o(a, b)  =>
| t as var => 
| var is t =>

| o       => // всегда просто создает переменную, потому что с маленькой буквы
| o()     => // матчит переменную все равно
| o(a, b) => // отказывается матчить потому что маленькая буква
| O(a, b) => // a и b переменные, O - тип
| O(A, B) => // паттерн конструктор A и B типы, если типов нет или не совместимы с полями, ошибка
| O       => // тип, если типа нет ошибка

| o       => // что мы хотим присвоить значение переменной или проверить что переменная имеет этот тип?
| o(a, b) => // что мы хотим присвоить поля объекта типа o, переменным a и b или же хотим проверить что типы полей совпадают с типами a и b?
| O       => // опять переменная или тип?

| A       =>

class Test
{
  public field : int;
}

// старый синтаксис:
def func1(obj : Test)
{
 match (obj)
 {
   | Test where (field = f) => f
 }
}

// новый синтаксис:
def func2(obj : Test)
{
 match (obj)
 {
   | Test @(field = f) => f
 }
}

with  - #
where - @
<-    - with

CE>with  - #
CE>where - @
CE><-    - with
CE>

| A(field = f) =>
| A(f)         =>

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)       => // совсем не упрощает синтаксис
}

public variant V
    | A 
        r : string
        s : double
    | B 
        z : int
        
    
  class C    
    
    public this()  
      
     mutable f: V
      
      match(f)
        | V.A => _ = f.r

А>public variant V
А>    | A 
А>        r : string
А>        s : double
А>    | B 
А>        z : int
        
    
А>  class C    
    
А>    public this()  
      
А>     mutable f: V
      
А>      match(f)
А>        | V.A => _ = f.r


А>

public this()  
{     
 def f : V;
 match (f)
 {
  | V.A as f => _ = f.r
 }
}

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 => //
}