public abstract class Expr : Located
{
    // Methods
    protected Expr();
    protected Expr(Location location);
    public override string ToString();

    [VariantOption]
    public sealed class Alias : Expr
    {
        // Fields
        public readonly Identifier id;

        // Methods
        public Alias(Identifier id);
        public Alias(Location location, Identifier id);
        public override int _N_GetVariantCode();
    }

    [VariantOption]
    public sealed class Assign : Expr
    {
        // Fields
        public readonly Identifier op;
        public readonly Expr to;
        public readonly Expr value;

        // Methods
        public Assign(Expr to, Expr value, Identifier op);
        public Assign(Location location, Expr to, Expr value, Identifier op);
        public override int _N_GetVariantCode();
    }

    [VariantOption]
    public sealed class Base : Expr
    {
        // Methods
        public Base();
        public Base(Location location);
        public override int _N_GetVariantCode();
    }

    [VariantOption]
    public sealed class BinaryOperator : Expr
    {
        // Fields
        public readonly Expr left;
        public readonly Identifier op;
        public readonly Expr right;

        // Methods
        public BinaryOperator(Expr left, Expr right, Identifier op);
        public BinaryOperator(Location location, Expr left, Expr right, Identifier op);
        public override int _N_GetVariantCode();
    }

    [VariantOption]
    public sealed class Call : Expr
    {
        // Fields
        public readonly list<FunctionArgument> arguments;
        public readonly Expr expr;

        // Methods
        public Call(Expr expr, list<FunctionArgument> arguments);
        public Call(Location location, Expr expr, list<FunctionArgument> arguments);
        public override int _N_GetVariantCode();
    }

VD>    [VariantOption]
VD>    public sealed class Alias : Expr
VD>    {
VD>        // Fields
VD>        public readonly Identifier id;

VD>>    [VariantOption]
VD>>    public sealed class Alias : Expr
VD>>    {
VD>>        // Fields
VD>>        public readonly Identifier id;
_FR>

match (ast)
{
  | Alias(id) => WriteLine(id);
  ... // другие образцы
}

VD>match (ast)
VD>{
VD>  | Alias(id) => WriteLine(id);
VD>  ... // другие образцы
VD>}

variant RgbColor
{ | Red
  | Yellow
  | Green
  | Different { red : float; green : float; blue : float; }
}

variant RgbColor
{ | Red
  | Yellow
  | Green
  | Different { Red : float; Green : float; Blue : float; }
}

VD>>match (ast)
VD>>{
VD>>  | Alias(id) => WriteLine(id);
VD>>  ... // другие образцы
VD>>}
_FR>

match (ast)
{
  | Alias(имяПараметраКонструктора=образец) => ...
  ... // другие образцы
}

_FR>variant RgbColor
_FR>{ | Red
_FR>  | Yellow
_FR>  | Green
_FR>  | Different { red : float; green : float; blue : float; }
_FR>}
_FR>

_FR>variant RgbColor
_FR>{ | Red
_FR>  | Yellow
_FR>  | Green
_FR>  | Different { Red : float; Green : float; Blue : float; }
_FR>}
_FR>

_FR>Ну в таком случае может вам свои гайдлайны начать писать? Имеющиеся-то не подходят, оказывается Нет уж. До тех пор, пока я не знал _почему_ имена полей вариантов таким образом выглядят было одно — просто необычно и неприятно. А теперь вот недоумеваэ.

VD>match (ast)
VD>{
VD>  | Alias(имяПараметраКонструктора=образец) => ...
VD>  ... // другие образцы
VD>}

_FR>Что-то я тут не увидел разницы Можно пример подробнее?

    [VariantOption]
    public sealed class BinaryOperator : Expr
    {
        // Fields
        public readonly Expr left;
        public readonly Identifier op;
        public readonly Expr right;

        // Methods
        public BinaryOperator(Expr left, Expr right, Identifier op);
        public BinaryOperator(Location location, Expr left, Expr right, Identifier op);
        public override int _N_GetVariantCode();
    }

  [Record]
  public variant Expr : Located
  {
    ...
    | BinaryOperator { left : Expr; left : Expr; op : Identifier; }
    ...

match (x)
{
  | Expr.BinaryOperator(_, _, Identifier where(Id="==")) => WriteLine("Оператор '==' !")
  | _ => WriteLine("Что-то другое.")
}

match (x)
{
  | Expr.BinaryOperator(op=Identifier where(Id="==")) => WriteLine("Оператор '==' !")
  | _ => WriteLine("Что-то другое.")
}

VD>  | Expr.BinaryOperator(_, _, Identifier where(Id="==")) => WriteLine("Оператор '==' !")

VD>  | Expr.BinaryOperator(op=Identifier where(Id="==")) => WriteLine("Оператор '==' !")

VD>  | Expr.BinaryOperator(op=Identifier where(Id="==")) => WriteLine("Оператор '==' !")

  [Record]
  public class Identifier : Located
  {
    [Accessor] Id : string;
    public override ToString() : string
    {
      id
    }
  }

type XColor = { X : double; Y: double; Z: double; }

public XColor(double x, double y, double z);

ВВ>>>Ну можно, наверное, сделать так, чтобы названия параметров конструкторов всегда переводились в кэмел, раз людей сей факт так беспокоит.

По этому если сделать имена полей с большой буквы, то с большой буквы будут и имена параметров конструкторов. Это еще хуже соотносится с гайдлайнами.

_FR>>По этому если сделать имена полей с большой буквы, то с большой буквы будут и имена параметров конструкторов. Это еще хуже соотносится с гайдлайнами.

VD>match (ast)
VD>{
VD> | Alias(id) => WriteLine(id);
VD> ... // другие образцы
VD>}
VD>

match (ast)
{
  | Alias(Id) => WriteLine(Id);
  ... // другие образцы
}

if(obj is ...) 
{
  var ast=(Alias)obj;
  With ast 
     WriteLine(.Id);
  End With
}

class A
{
    int[] x = { };
}

using System;

unsafe class C
{
    int* x = (int*) -1;
}

class A
{
    static void Main()
    {
        object[] p = null;
        var q = from x in p
                where x is int?
                select x;
    }
}

using System;

class C : IDisposable
{
    public void Dispose() {}

    public static C operator *(C x, C y)
    {
        using (x * y * y)
        {
            return x;
        }
    }
}

class P
{
    static void Main()
    {
        using (C? x = new C() + from y in new[] { 1 }
                                join z in new[] { 1 } on y equals z
                                let s = y + z
                                select s is int ? "" : null) { }
    }
}

class A
{
    static void Foo()
    {
        a:
    }
}

class A
{
    object x = List<List<>>.Foo;
}

class A
{
    object x = &&1;
}

class C
{
    bool? b = i is int?? true : false;
}

class \u1000<[typevar:X]T>
{
    [@return:X]
    void Foo() { }
}

using x = int;
using y = List<int<int>>;

class A{
    object x = from from in "" select 1;
}