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

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

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);
}

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?

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

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()));

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

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.

TryParse(text).Do(WriteLine);

и с введением not null references необходимость в Option отпадёт окончательно

Frameworks must be designed starting from a set of usage scenarios and code samples implementing these scenarios

var optionalResult = int.TryParse(text).Select(res => что-то делаем со значением);

public (int, int) Tally(IEnumerable<int> values) 
{
...
}

...
{
  // Как нам нравится, так и матчим
  (var sum, var count) = Tally(myValues); // Хотим так...
  (int s, int c) x = Tally(myValues) // А можем и так
  (long y, long) z = Tally(myValues); // Если кортежи не инварианты (вот честно не помню, как с этим в C#), то можно и так. Если надо.
}

G>public (int, int) Tally(IEnumerable<int> values) 
G>{
G>...
G>}

G>...
G>{
G>  // Как нам нравится, так и матчим
G>  (var sum, var count) = Tally(myValues); // Хотим так...
G>  (int s, int c) x = Tally(myValues) // А можем и так
G>  (long y, long) z = Tally(myValues); // Если кортежи не инварианты (вот честно не помню, как с этим в C#), то можно и так. Если надо.
G>}
G>

Pair<int, int> F();

// vs.

class Data { int Width; int Height; }
Data F();

public (int Sum, int Count) Tally(IEnumerable<int> values) 
{
...
}

...
{
  // Как нам нравится, так и матчим
  (var sum, var count) = Tally(myValues); // Хотим так...
  (int s, int c) x = Tally(myValues) // А можем и так
  (long y, long) z = Tally(myValues); // Если кортежи не инварианты (вот честно не помню, как с этим в C#), то можно и так. Если надо.
}

G>Пока — судя по тому что я читал... да хоть тот же proposal — что-то не сильно похоже Да один splatting чего только стоит

G> Вот только C# к этим ФЯ не относится.

G>Ну, всё таки парни там не настаивают сильно на номинативной типизации таких "кортежей". С другой стороны, когда я это читаю, у меня создается стойкое ощущение... легкого недоумения — они это серьезно?!

G>public (int, int) Tally(IEnumerable<int> values) 
G>...
G>  (var sum, var count) = Tally(myValues); // Хотим так...
G>  (int s, int c) x = Tally(myValues) // А можем и так
G>

(var count, var sum) = Tally(myValues); // Все перепутали, но кто же нас проверит?!

(var x, var age) = Tally(myValues); // Все перепутали, но кто же нас проверит?!

a.Item1.Item3.Item2.Item5

var t = (int a, int b) => new (int x, int y) {x = a, y = b};
t(t(1,2)); // splatting;

var (int a, int b) A;
var (int x, int y) B;

G>> Вот только C# к этим ФЯ не относится.

G>>Ну, всё таки парни там не настаивают сильно на номинативной типизации таких "кортежей". С другой стороны, когда я это читаю, у меня создается стойкое ощущение... легкого недоумения — они это серьезно?!

public (int sum, int count) Tally(IEnumerable<int> values) 
{
  ...
}

...

(double sum, long count) weaken = Tally(...); // why not?
(int s, int c) rename = Tally(...) // why not?

VD>(var count, var sum) = Tally(myValues); // Все перепутали, но кто же нас проверит?!
VD>

VD>(var x, var age) = Tally(myValues); // Все перепутали, но кто же нас проверит?!
VD>

G>var t = (int a, int b) => new (int x, int y) {x = a, y = b};
G>t(t(1,2)); // splatting;
G>

G>Вот и ты туда же... как и авторы "предложения" Ну, или либо чего-то не понимаю.

G>var (int a, int b) A;
G>var (int x, int y) B;
G>

class A
{
  publib int X;
}

class B
{
  publib int X;
}

G>в моем представлении, имеет не много общего с номинативной типизацией. Из предложения вообще, имхо, местами весьма трудно понять "чего таки хотим"... какую такую "проблему" решаем