Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Я уже привёл аргументы выше, и не раз.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Тогда уж вводите оператор правостороннего присваивания для полной математической красоты

var x = SomeFunction(); //pure
SomeFunction() to var x; //pure

и повторяйте все ваши манипуляции с ним…

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

default var
case var
case object
Так себе аргумент с визуальной сложностью.

Во-вторых, вывод типа никуда не делся.

В-третьих, добавилось неочевидное поведение с null.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Нет, я не считаю это лучшим синтаксисом, он просто доступен мне уже сейчас в качестве альтернативы. Я только считаю, что is var / case var реализованы некрасиво без явной на то необходимости, вот и всё.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Когда у вас этот матчинг воткнут внутрь какого-нибудь актора, который должен очень быстро обрабатывать сообщения, и матч-кейсов много — да, это кошмар.

Тут уже возникает вопрос, а стоит ли вообще применять стандартный матчинг в swich с его подводными упаковками…

А если у вас несколько матч-кейсов?

Не понял вас, то одним делегатом нужно, то уже двумя.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Подождите, где я убрал var x?

var x = SomeFunction(); //pure
Do(x);
Other(x);

полностью семантически эквивалентно

Do(SomeFunction());
Other(SomeFunction());

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Вы не понимаете проблемы, кажется: default var будет конфликтовать с case var вне зависимости от поведения case var

С чего вдруг?
case var матчит любой случай кроме null
default var матчит любой случай вместе с null
Даже удобнее получается.

Какого именно прежнего значения?

Вывод типа и только.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Тогда мне вот что интересно, как же вы собираетесь применять подстановку для случая

var x = SomeFunc(); //pure
Do(x.DoSomethingWith(x));
Other(x.DoSomethingWith(x));

нет здесь побочных эффектов?

Наверное, так

Do(SomeFunc().DoSomethingWith(SomeFunc()));
Other(SomeFunc().DoSomethingWith(SomeFunc()));

Вы убрали var x = . Так уберите To(out var p) и получите тот же результат.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Так в том и дело, зачем было вообще создавать этот конфликт и нарушать симетрию, если можно было сразу всё сделать красиво? Вы мне лучше на этот вопрос ответьте, а то ходите по кругу: is var всегда true, потомучто case var всегда true, а default var не подойдёт, потому что есть уже case var.

Мне неинтересны аргументы, почему такое решение не подойдёт сейчас, я сам всё это прекрасно понимаю.

Вы мне объясните, зачем сделали именно так, а не иначе… В чём проблема сохранения прежнего значения var?

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Попробуйте так

Do(SomeFunction().To(out var x).DoSomethingWith(x));
Other(SomeFunction().To(out var y).DoSomethingWith(y));

или раз уж на то пошло

SomeFunction().To(out var p); //pure
Do(SomeFunction().DoSomethingWith(p));
Other(SomeFunction().DoSomethingWith(p));

Да и вообще хорошо, что ваш пример не компилируется, поскольку в C# методы в основном не чистые да и многие типы изменяемые, что защищает от написания неоптимального кода.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Да пользуйтесь, чем вам хочется. Я что, склоняю вас к чему-то? Все эти примеры предназначены в основном для тех, кто предпочитает использовать var в классическом значении вывода типа.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Проблем с default var не больше, чем с case var.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Кошмар.

Можно реализовать и одним делегатом, но мне больше нравится отделять проверку на null.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Если очень нужна деструкция

(SomeRecord r) =>
{
    var (x,y,z) = r;
    SomeFun(x, y, z);
}

Матчинг по значениям можно добавлять, например, так

(Person p) =>
    p.ToSwitch(
        p.FirstName.To(out var name),
        p.Age.To(out var age)
    ).Is(out var sw) &&

    sw.Case("Jack", 32) ? "Jack is 32" :
    sw.Case("Alice", 16) ? "A is 16" :
    sw.Case("Piter", age) ? "P age" :
    sw.Case(name, 12) ? "young" :
    sw.Case(name, age) ? "any" :

   "unreachable",

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Под «они разделены» я понимаю «они не смешаны», это моё уточнение для вас, поскольку возникли вопросы.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Вы лучше на примере поясните, где и что нужно подставить, а в моём коде нельзя так сделать…

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Но, на мой взгляд, default var p выглядит очень даже ничего…

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Можно скомпилировать уже сейчас

var result = someThing.Match(
    (SomeRecord r) => SomeFun(r.x, r.y, r.z),
    (object o) => throw new InvalidArgumentException()
);

null можно обработать двумя способами

someThing?.Match

либо

    () => throw new InvalidArgumentException()

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Обратите внимание, раньше вы говорили, что они разделены, теперь вы говорите, что они скомпонованы. А часа не прошло.

Они не смешаны в F#.

Исправлять ли unexpected behavior в C# 7 или оставить как есть, усложнив синтаксис языка для компенсации?

Я указал выше, что это псевдокод. var означает только вывод типа компилятром из контекста в классическом понимании.