Languages (available for .NET Framework and .NET Core)

Bring functional programming concepts to .NET languages
* Tuples
* Pattern matching

Performance and Code Quality
* Value Tasks
* Ref returns
* Throw expressions
* Binary literals
* Digit separators

Developer Productivity
* Out vars
* Local functions

if (double.TryParse(text, out var parsed))
{
  // use parsed value here.
}

S>Не всё, чего нет в %мой_любимый_язык%, является костылём

S>if (double.TryParse(text, out var parsed))
S>{
S>  // use parsed value here.
S>}
S>

when (double.Parse(text) is Some(value))
{
  WriteLine(value);
}

when (double.Parse(text) is Some(value))
{
  WriteLine(value);
}

if (double.TryParse(text, out var parsed))
{
  WriteLine(parsed);
}

// vs
if (double.TryParse(text) is Some(var parsed)) // в c#7/8 оно примерно так выглядит
{
  WriteLine(parsed);
}

var data = WebHelpers.TrySendRequest(param)?.Result.SomeField?.ToString();

// vs
var data = WebHelpers.TrySendRequest(param) switch(
    case None: None.From<string>();
    case Some x: x.Result.SomeField switch(
        case None y: y;
        case Some z: z.ToString()));

S>if (double.TryParse(text, out var parsed))
S>{
S>  WriteLine(parsed);
S>}

S>// vs
S>if (double.TryParse(text) is Some(var parsed)) // в c#7/8 оно примерно так выглядит
S>{
S>  WriteLine(parsed);
S>}
S>

S>Про то, как будет выглядеть метод с парой out — не советую. Съедят

if (MyParser.TryParse(text, out var left, out var right) { WriteLine($"{left} - {right}") }
if (MyParser.TryParse(text) is Some(var parsed)) { WriteLine($"{parsed.Left} - {parsed.Right}") }

if (MyParser.TryParse(text) is Some (( var left, var right ))) { WriteLine($"{left} - {right}") } // ага, двойные скобки -)

var data = WebHelpers.TrySendRequest(param)?.Result.SomeField?.ToString();

if (MyDouble.TryParse(text) is (true, var parsed)) // double? MyDouble.TryParse(string text)
{
   WriteLine(parsed);
}

    if (!int.TryParse(str, out var value)) return false;
    // тут юзаем value

The reason for this rule is that we expect people to often write code like

if (o is FooNode node && node.Whatever) { ... code using node ... } else
if (Something && o is BarNode node) { ... code using node ... } else
if (o is BazNode node) { ... code using node ... }

and we don't want to force them to have to think up new names for every node. ...
Also we don't want different but overlapping scoping rules for pattern variables and these "out" variables.

S>if (double.TryParse(text, out var parsed))
S>{
S>  // use parsed value here.
S>}
S>

if (double.TryParse(text) is (true, parsed))
{
  // use parsed value here.
}

S>Ну и чтоб два раза не вставать, ваш аналог для ref?