class A
{
 public X : int { get; }
 
 public this()
 {
  X = 1; // Транслируется в hidden_field_X = 1;
  F(ref X); // F(ref hidden_field_X)
 }
}

class A
{
 public X : int { get; default 1 }
 public Y : int { get; set; default 2 }
}

public F(params int[] x) { }

F(1,2,3) // F(new [] {1,2,3})

var x = y as X;
if (x != null)
...

var (a, b, c) = new Tuple(42, "a", 2.3);

VD>var (a, b, c) = new Tuple(42, "a", 2.3);
VD>

public var F()
{
  return new { Name = "A", Age = 10 };
}

ЕА>public var F()
ЕА>{
ЕА>  return new { Name = "A", Age = 10 };
ЕА>}
ЕА>

public <string Name, int Age> F()
{
  return new { Name = "A", Age = 10 };
}

public class Point(int x, int y)
{
  public int X => x;
  public int Y => y;
  public int Dist { get; } = Math.Sqrt(x * x + y * y);
}

int Prop1 { get; default 42; }
int Prop2 { get x * y; default 42; }
int Prop3 { get { x * y; } default 42; }
int Prop3 { get { return x * y; } default 42; }

int Foo() = 42;

private int _x = x;
public int X { get { return x; } }

var a = (var x = Foo(); var y = Bar(x); FooBar(y));

var x = Foo(out var x, out var y);

AVK>var a = (var x = Foo(); var y = Bar(x); FooBar(y));
AVK>

public noreturn int X { get { 1 } }

AVK>var x = Foo(out var x, out var y);
AVK>

mutable x, y;
def z = Foo(out x, out y);

_NN>mutable x, y;
_NN>def z = Foo(out x, out y);
_NN>

var x = !map.TryGetValue(42, out var value) ? value : -1;

var q = if(true)=> 1 else 2;

_NN>>Что тело 'then' и 'else' будет выражением а не просто блоком кода, т.е. что-то возвращает и тогда это можно будет использовать справа от присваивания

Это сломает совместимость. Впрочем, кое что на эту тему, возможно, будет:
var a = (var x = Foo(); var y = Bar(x); FooBar(y));

var a = true 
    ? (var x = Foo(); var y = Bar(x); FooBar(y)) 
    : (var x = FooBar(10); var y = Bar(x - 5); FooBar(y));

if ((var y = x as SomeClass) != null)
    Foo(y);
else
  Bar();

<int a; string b;> Foo()
{
  return new { a=42, b="text" };
}

X : int { get; } = 42;

public class Point
{
  private int x;
  private int y;

  public Point(int x, int y)
  {
    this.x = x;
    this.y = y;
  }  
}

А>Больше говнокода! Даёшь жабоскрипт!

public class Person(string name) 
{
  if (string.IsNullOrEmpty(name))
    throw new ArgumentException("name", "name must be a non-empty string!");
}

Это аналогично немерловой макре Record, но несколько более гибко, так как можно реализовать логику в кострукторе.

public int X { get; } = x
// при наличии
public int X { get { return x; } }

S>public int X { get; } = x
S>// при наличии
S>public int X { get { return x; } }
S>

S>?

public int X { get; } = x

public int X { get { return _x; } }
private readonly int _x = x;

public int X { readonly x; get; }

S>и то логичнее смотрится

class Q
{
  public X : int { get; } // Создаем поля для чтения
  public Y : int { get; default 1 } // Создаем поля для чтения + инициализация
  public Z : int { get; set; default 2 } // Создаем поля для чтения и записи + инициализация
 
  public this()
  {
    F(out X); // out применяется к внутреннему полю
  }
  
  F(out x : int) { x = 1; }
}

S>public int X { get; } = x
S>// при наличии
S>public int X { get { return x; } }
S>

S>?

public int X { get; } = x

// при наличии
private int _x = x;
public int X { get { return _x; } }

var a = 5;

if (condition)
  a = 10;

// и

var a = if (condition) 5 else 10;

var x = using (var db = new Db())
{
  (from a in db.Table1
  from b in db.Table2
  from c in db.Table3
  select new {a.X, b.Y, c.Relation1.GroupBy(x => x.Z)}).ToArray();
}
CallMethodWithArgument(x);

Z>var x = using (var db = new Db())
Z>{
Z>  (from a in db.Table1
Z>  from b in db.Table2
Z>  from c in db.Table3
Z>  select new {a.X, b.Y, c.Relation1.GroupBy(x => x.Z)}).ToArray();
Z>}
Z>CallMethodWithArgument(x);
Z>

MyType x;
using (var db = new Db())
{
  x = (from a in db.Table1
  from b in db.Table2
  from c in db.Table3
  select new {a.X, b.Y, c.Relation1.GroupBy(x => x.Z)}).ToArray();
}
CallMethodWithArgument(x);

// Неплохо.
public int X { get; } = x;

// А зачем? о.о
public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

// Пригодится.
public Point Average(params IEnumerable<Point> points) { }

// О даааааааааааааа! ^____________^
if (points?.FirstOrDefault()?.X ?? -1) { }

// Удобно.
var t = new Tuple(1,2); // infers Tuple<T1, T2>

// Хмммм... А как это работает? С generic-ами всё ясно, а тут...
public void Foo(out var x, out var y) { }