Исправлять ли 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 означает только вывод типа компилятром из контекста в классическом понимании.

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

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

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

для кода не определены правила эквивалентного преобразования

Может, не помешало бы их ввести? Как думаете?

Вам не надоело еще видеть этот пример?

Встречный вопрос, не надоело?

switch(GetPerson())
{
  case Employee e:
    //only when e is Employee
    break;
  default var p:
    //all other cases for p
    break;
}

switch(GetPerson().To(out var p))
{
  case Employee e:
    //only when e is Employee
    break;
  default:
    //all other cases for p
    break;
}

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

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

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

Это грамотная композиция, а не смешение. Мы берём фичи A и B, комбинируем и получаем C=AB, а не С=XB, где X это как A, но уже не совсем в данном контексте.

Как по вашему должен работать такой псевдокод

match shape with
| Square(2, 2) -> 1
| Circle(4, 5) -> 0
| var(0, 0) -> 3 // Shape(0, 0) -> 3

где базовый Shape (выведенный тип для var) поддерживает деконструкцию?

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

Аргументировать я предлагаю кодом, потому что это наиболее строгий подход — это как вывод формул в математике.

Если я пишу

Person GetPerson() => ...

GetPerson().Is(out Person p)

и далее естественным образом заменяю на

GetPerson().Is(out var p)

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

GetPerson() is Person p
GetPerson() is var p

Увы, эта симетрия нарушена… Почему? Может, вы мне поясните примерами кода, где это крайне необходимо?

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

Я и говорю: мнение других вас не волнует.

Меня волнуют аргументированные мнения.