C# 6.0
От: Аноним  
Дата: 08.12.13 07:29
Оценка: 46 (6) +2
http://adamralph.com/2013/12/06/ndc-diary-day-3/
//primary constructors - 
public class Point(int x, int y) { }
//read only auto-properties - 
public int X { get; } = x;
//static type using statements - 
using System.Math;
//property expressions - 
public double Distance => Sqrt(X * X + Y * Y);
//method expressions - 
public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
//params for enumerables - 
public Point Average(params IEnumerable<Point> points) { }
//monadic null checking - 
if (points?.FirstOrDefault()?.X ?? -1) { }
//constructor type parameter inference - 
var t = new Tuple(1,2); // infers Tuple<T1, T2>
//inline declarations for out params - 
public void Foo(out var x, out var y) { }

Имхо, какой то хоть и полезный но хлам.
Re: C# 6.0
От: Nikolay_Ch Россия  
Дата: 08.12.13 08:01
Оценка:
Здравствуйте, Аноним, Вы писали:

Хлам, не хлам, а какое-то движение есть...
Re: C# 6.0
От: adontz Грузия http://adontz.wordpress.com/
Дата: 08.12.13 08:02
Оценка:
Здравствуйте, Аноним, Вы писали:

Extension properties хочу. Хотя, monadic null checking и constructor type parameter inference тоже ничего.
A journey of a thousand miles must begin with a single step © Lau Tsu
Re: C# 6.0
От: Jack128  
Дата: 08.12.13 09:52
Оценка:
Здравствуйте, Аноним, Вы писали:

А>
А>//method expressions - 
А>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
А>

А в чем смысл?? чем это лучше public Point Move(int dx, int dy) { return new Point(X + dx, Y + dy); }
return убрали, да вместо скобок "=>" поставили ?? чёто не очень.


Собственно главный вопрос: ГДЕ pattern matching ???
Re[2]: C# 6.0
От: Don Reba Канада https://stackoverflow.com/users/49329/don-reba
Дата: 08.12.13 10:33
Оценка: 1 (1) +1 :)
Здравствуйте, Jack128, Вы писали:

J>Собственно главный вопрос: ГДЕ pattern matching ???


В Немерле.
Ce n'est que pour vous dire ce que je vous dis.
Re: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 08.12.13 19:36
Оценка:
Здравствуйте, Аноним, Вы писали:

А>http://adamralph.com/2013/12/06/ndc-diary-day-3/


А>

А>//primary constructors —
А>public class Point(int x, int y) { }


А>//read only auto-properties —

А>public int X { get; } = x;
А как это работает ?
Что означает "= x" ? Это инициализация или имя переменной ?

Можно ли как в Nemerle ?
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 }
}



А>//static type using statements —

А>using System.Math;
Давно пора

А>//property expressions —

А>public double Distance => Sqrt(X * X + Y * Y);
А>//method expressions —
А>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
Проще разрешить выражения и убрать 'return', тогда не нужно ничего придумывать и использовать обычные свойства и методы.

А>//params for enumerables —

А>public Point Average(params IEnumerable<Point> points) { }
Я так понимаю для этого нужно менять рантайм. Верно ?

А>//monadic null checking —

А>if (points?.FirstOrDefault()?.X ?? -1) { }
Полезная фича, давно реализуемая в других языках.

А>//constructor type parameter inference —

А>var t = new Tuple(1,2); // infers Tuple<T1, T2>
Ну наконец.
Хотя наверное только из конструктора выводит, или как в Nemerle где может вывести из использования ?

А>//inline declarations for out params —

А>public void Foo(out var x, out var y) { }
Практикуют программирование на 'out' типах ?
Не проще ли кортежи добавить в язык ?
На мой взгляд как раз в публичных методах, которые являются контрактом класса, как раз не нужен вывод типов.

А>

А>Имхо, какой то хоть и полезный но хлам.
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[2]: C# 6.0
От: Jack128  
Дата: 08.12.13 20:23
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Здравствуйте, Аноним, Вы писали:


А>>http://adamralph.com/2013/12/06/ndc-diary-day-3/


А>>

А>>//primary constructors —
А>>public class Point(int x, int y) { }


А>>//read only auto-properties —

А>>public int X { get; } = x;
_NN>А как это работает ?
_NN>Что означает "= x" ? Это инициализация или имя переменной ?

x в данном случае — это поле. Обрати внимание на primary constructor выше, скорее всего как F#, его параметры в поля преобразуются.

А>>//params for enumerables —

А>>public Point Average(params IEnumerable<Point> points) { }

_NN>Я так понимаю для этого нужно менять рантайм. Верно ?

нафиг? params — это ж вроде как просто указание, что вызов Average(1,2,3,4) преобразовывать в Average(new[] {1,2,3,4}). Причем тут вообще рантайм?
Re[3]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 08.12.13 20:32
Оценка:
Здравствуйте, Jack128, Вы писали:

А>>>

А>>>//primary constructors —
А>>>public class Point(int x, int y) { }

А>>>//read only auto-properties —

А>>>public int X { get; } = x;
_NN>>А как это работает ?
_NN>>Что означает "= x" ? Это инициализация или имя переменной ?

J>x в данном случае — это поле. Обрати внимание на primary constructor выше, скорее всего как F#, его параметры в поля преобразуются.

А зачем оно тогда нужно ?
Почему в поля ? Я как раз думаю в случае C# будут свойства для чтения.

А>>>//params for enumerables —

А>>>public Point Average(params IEnumerable<Point> points) { }

_NN>>Я так понимаю для этого нужно менять рантайм. Верно ?

J>нафиг? params — это ж вроде как просто указание, что вызов Average(1,2,3,4) преобразовывать в Average(new[] {1,2,3,4}). Причем тут вообще рантайм?
Ну так оно и сейчас так через массив.
public F(params int[] x) { }

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


Я так понимаю фишка в том, что IEnumerable как раз даст возможность не создавать массив вообще, а скажем , разместить все в стеке.
Иначе снова неясно зачем это.
Массив он и так IEnumerable.
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[4]: C# 6.0
От: nikov США http://www.linkedin.com/in/nikov
Дата: 08.12.13 20:53
Оценка: +2
Здравствуйте, _NN_, Вы писали:

_NN>Иначе снова неясно зачем это.

_NN>Массив он и так IEnumerable.

Сейчас можно передавать только существующий массив или список аргументов (который преобразуется в массив в месте вызова).
А с params IEnumerable<T> можно будет, кроме того, передавать любые коллекции: List<T>, HashSet<T> и т.д., избегая от ненужного вызова .ToArray() и копирования элементов.
Re[2]: C# 6.0
От: nikov США http://www.linkedin.com/in/nikov
Дата: 08.12.13 21:02
Оценка: 35 (3) +1
Здравствуйте, _NN_, Вы писали:

А>>//read only auto-properties —

А>>public int X { get; } = x;
_NN>А как это работает ?
_NN>Что означает "= x" ? Это инициализация или имя переменной ?
Это инициализация скрытого поля соответствующего авто-свойству. Может быть любым выражением, разрешённым в инициализаторах полей. Выполняется при создании объекта.

_NN>Хотя наверное только из конструктора выводит, или как в Nemerle где может вывести из использования ?

Только из аргументов конструктора.

А>>//inline declarations for out params —

А>>public void Foo(out var x, out var y) { }
_NN>На мой взгляд как раз в публичных методах, которые являются контрактом класса, как раз не нужен вывод типов.
Это автор блога что-то намудрил. Предполагается разрешить такой синтаксис при вызовах методов с out-параметрами, а не при их декларации.
Re[3]: C# 6.0
От: Аноним  
Дата: 09.12.13 05:18
Оценка:
Здравствуйте, nikov, Вы писали:
N>Это автор блога что-то намудрил. Предполагается разрешить такой синтаксис при вызовах методов с out-параметрами, а не при их декларации.
А когда будет что нибудь более официальное на этот счет? И будут ли какие то более интересные фичи, или это весь список нововведений?
Re[3]: C# 6.0
От: Jack128  
Дата: 09.12.13 06:51
Оценка: +1 :))
Здравствуйте, nikov, Вы писали:

А>>>//inline declarations for out params —

А>>>public void Foo(out var x, out var y) { }
_NN>>На мой взгляд как раз в публичных методах, которые являются контрактом класса, как раз не нужен вывод типов.
N>Это автор блога что-то намудрил. Предполагается разрешить такой синтаксис при вызовах методов с out-параметрами, а не при их декларации.

Правильно. По мне так дальше нужно идти, не только облегчить работу с out-параметрами, но еще и максимально усложнить работу с туплами. Чтоб даже мысли не возникало их использовать.
Re: C# 6.0
От: Grundik2 Земля  
Дата: 09.12.13 08:26
Оценка: :)
Здравствуйте, Аноним, Вы писали:

А>http://adamralph.com/2013/12/06/ndc-diary-day-3/

А>
А>//primary constructors - 
А>public class Point(int x, int y) { }
А>//read only auto-properties - 
А>public int X { get; } = x;
А>//static type using statements - 
А>using System.Math;
А>//property expressions - 
А>public double Distance => Sqrt(X * X + Y * Y);
А>//method expressions - 
А>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
А>//params for enumerables - 
А>public Point Average(params IEnumerable<Point> points) { }
А>//monadic null checking - 
А>if (points?.FirstOrDefault()?.X ?? -1) { }
А>//constructor type parameter inference - 
А>var t = new Tuple(1,2); // infers Tuple<T1, T2>
А>//inline declarations for out params - 
А>public void Foo(out var x, out var y) { }
А>

А>Имхо, какой то хоть и полезный но хлам.

у Scala передрали.
Re[5]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 09.12.13 09:31
Оценка:
Здравствуйте, nikov, Вы писали:

N>Сейчас можно передавать только существующий массив или список аргументов (который преобразуется в массив в месте вызова).

N>А с params IEnumerable<T> можно будет, кроме того, передавать любые коллекции: List<T>, HashSet<T> и т.д., избегая от ненужного вызова .ToArray() и копирования элементов.

Теперь логично, а то я уже подумал про супер оптимизацию для params
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[2]: C# 6.0
От: achmed Удмуртия https://www.linkedin.com/in/nail-achmedzhanov-9907188/
Дата: 10.12.13 04:55
Оценка:
Здравствуйте, Jack128, Вы писали:
А>>
А>>//method expressions - 
А>>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
А>>

J>А в чем смысл?? чем это лучше public Point Move(int dx, int dy) { return new Point(X + dx, Y + dy); }
J>return убрали, да вместо скобок "=>" поставили ?? чёто не очень.

Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.
Re[3]: C# 6.0
От: Jack128  
Дата: 10.12.13 10:26
Оценка:
Здравствуйте, achmed, Вы писали:

A>Здравствуйте, Jack128, Вы писали:

А>>>
А>>>//method expressions - 
А>>>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);
А>>>

J>>А в чем смысл?? чем это лучше public Point Move(int dx, int dy) { return new Point(X + dx, Y + dy); }
J>>return убрали, да вместо скобок "=>" поставили ?? чёто не очень.

A>Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.


Не понял, честно говоря. Можно примером пояснить?
Re[2]: C# 6.0
От: G-Host  
Дата: 10.12.13 10:52
Оценка:
Здравствуйте, Grundik2, Вы писали:

G>у Scala передрали.


Джаве тоже пора что-нибудь передрать. Хотя бы у Шарпа.
Re[3]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 10.12.13 11:00
Оценка: :)
Здравствуйте, G-Host, Вы писали:

GH>Джаве тоже пора что-нибудь передрать. Хотя бы у Шарпа.


Java 8.
Или вам что-то конкретное нужно ?
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[2]: C# 6.0
От: Константин Черногория  
Дата: 11.12.13 21:20
Оценка: +1
Здравствуйте, _NN_, Вы писали:

А>>//inline declarations for out params —

А>>public void Foo(out var x, out var y) { }
_NN>Практикуют программирование на 'out' типах ?
_NN>Не проще ли кортежи добавить в язык ?
Проще, но хуже. У out-аргументов кроме типов есть ещё имена. У членов кортежа только типы.
Поэтому если метод возвращает два значения одного или близких типов, то при использовании двух out аргументов метод можно использовать, не заглядывая в документацию, а только взглянув на прототип. При использовании же кортежа, из прототипа метода уже не следует, где какой результат.

P.S. Понятно, что для (x,y) координат стоит завести класс или структуру (потому шо если алгоритм работает с геометрией то эти 2 значения постоянно передаются вместе + у них куча общей логики).
Однако бывают такие функции, результат которых бессмысленно оборачивать в класс/структуру. Например Math.DivRem из таких.
Re[3]: C# 6.0
От: hardcase Пират http://nemerle.org
Дата: 12.12.13 11:57
Оценка:
Здравствуйте, Константин, Вы писали:

К>Проще, но хуже. У out-аргументов кроме типов есть ещё имена. У членов кортежа только типы.

К>Поэтому если метод возвращает два значения одного или близких типов, то при использовании двух out аргументов метод можно использовать, не заглядывая в документацию, а только взглянув на прототип.

Практика использования кортежей в языках, где они изначально поддерживаются, показывают одну особенность: их крайне редко их выставляют в публичный интерфейс.
/* иЗвиНите зА неРовнЫй поЧерК */
Re[3]: C# 6.0
От: Ikemefula Беларусь http://blogs.rsdn.org/ikemefula
Дата: 13.12.13 10:11
Оценка:
Здравствуйте, achmed, Вы писали:

J>>А в чем смысл?? чем это лучше public Point Move(int dx, int dy) { return new Point(X + dx, Y + dy); }

J>>return убрали, да вместо скобок "=>" поставили ?? чёто не очень.

A>Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.


Сильно вряд ли. Это ограничение искусственное. Процессоры Expression очевидно не умеют интерпретировать весь C#, только экспрешны. Сильно вряд ли Linq Provider будет в курсе, как интерпретировать switch или yield. Вот и обрезали до экспрешнов.
Re[4]: C# 6.0
От: achmed Удмуртия https://www.linkedin.com/in/nail-achmedzhanov-9907188/
Дата: 14.12.13 12:47
Оценка:
Здравствуйте, Jack128, Вы писали:

A>>Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.

J>Не понял, честно говоря. Можно примером пояснить?
ровать
Я имел в виду Code Quotations F#. Но ошибся.
Re[4]: C# 6.0
От: achmed Удмуртия https://www.linkedin.com/in/nail-achmedzhanov-9907188/
Дата: 14.12.13 12:50
Оценка:
Здравствуйте, Ikemefula, Вы писали:

I>Здравствуйте, achmed, Вы писали:


J>>>А в чем смысл?? чем это лучше public Point Move(int dx, int dy) { return new Point(X + dx, Y + dy); }

J>>>return убрали, да вместо скобок "=>" поставили ?? чёто не очень.

A>>Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.


I>Сильно вряд ли. Это ограничение искусственное. Процессоры Expression очевидно не умеют интерпретировать весь C#, только экспрешны. Сильно вряд ли Linq Provider будет в курсе, как интерпретировать switch или yield. Вот и обрезали до экспрешнов.


Switch и пр. существуют в природе http://msdn.microsoft.com/ru-ru/library/dd268013(v=vs.110).aspx, только сахара нет.
Чем черт не шутит, добавят в C# 7.0
Re[5]: C# 6.0
От: Ikemefula Беларусь http://blogs.rsdn.org/ikemefula
Дата: 14.12.13 15:23
Оценка:
Здравствуйте, achmed, Вы писали:

A>>>Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.


I>>Сильно вряд ли. Это ограничение искусственное. Процессоры Expression очевидно не умеют интерпретировать весь C#, только экспрешны. Сильно вряд ли Linq Provider будет в курсе, как интерпретировать switch или yield. Вот и обрезали до экспрешнов.


A>Switch и пр. существуют в природе http://msdn.microsoft.com/ru-ru/library/dd268013(v=vs.110).aspx, только сахара нет.

A>Чем черт не шутит, добавят в C# 7.0

А я где то сказал, что этого нет в природе ? Ни один из LInq провайдеров не умеет этих свичей. Так понятно ?
Re: C# 6.0
От: Аноним  
Дата: 14.12.13 18:28
Оценка:
Здравствуйте, Аноним, Вы писали:

А>//primary constructors —

А>public class Point(int x, int y) { }

Кто-нибудь может объяснить, что это? А то все читают с таким видом, будто это есть во всех языках и только c# наконец до этого докатился!

А>//static type using statements —

А>using System.Math;

Это как в Немерле — импорт класса и вызов в коде статических методов без указания класса?

А>//monadic null checking —

А>if (points?.FirstOrDefault()?.X ?? -1) { }

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

А что там народ заикался про множественный return? Разве это возможно? (без хаков) Мой эксперимент на MSIL показал, что возврат из функции с более чем одним элементом на стеке сразу разрывает на куски. Т.е. "напрямую" не получится, значит опять индусские дуроломы прикрутят на изоленте hidden class, который будет прятать в себе массив возвращаемых значений.
Re[3]: C# 6.0
От: nikov США http://www.linkedin.com/in/nikov
Дата: 16.12.13 18:08
Оценка: +1
Здравствуйте, achmed, Вы писали:

A>Можно предположить что на Expression можно будет разбирать отдельные методы а не только выражения. Как в F#.


Это было бы чересчур смелое предположение.
Re[4]: C# 6.0
От: nikov США http://www.linkedin.com/in/nikov
Дата: 16.12.13 18:19
Оценка: +1
Здравствуйте, Аноним, Вы писали:

А>А когда будет что нибудь более официальное на этот счет? И будут ли какие то более интересные фичи, или это весь список нововведений?


Пока что это список идей для гипотетических будущих версий C#. Некоторые из этих идей прототипировались, однако не нужно воспринимать пару слайдов на конференции как официальное объявление новых фич или как обязательство реализовать их в ближайшей следующей версии. Скорее, это приглашение к неформальной дискуссии, чтобы лучше понять, в чём нуждаются разработчики.
Re: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 16.12.13 18:26
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>Имхо, какой то хоть и полезный но хлам.


Фокус этого релиза — новый компилятор и language service в студии, глобальных фич ожидать не стоит. И это, на самом деле, хорошо, потому что ели бы были глобальные фичи, мелочи бы опять остались нереализоованными.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[2]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 16.12.13 18:26
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>>//primary constructors —

А>>public class Point(int x, int y) { }
А>Кто-нибудь может объяснить, что это? А то все читают с таким видом, будто это есть во всех языках и только c# наконец до этого докатился!

Синтаксический сахар. Транслируется в такое:
public class Point
{
  private int x;
  private int y;

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


А>>//static type using statements —

А>>using System.Math;
А>Это как в Немерле — импорт класса и вызов в коде статических методов без указания класса?

Да. Причем для extension методов тоже будет работать.

А>>//monadic null checking —

А>>if (points?.FirstOrDefault()?.X ?? -1) { }

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

А>Мрак, если откровенно.

Мрак в чем? Если в синтаксисе, то это не окончательный вариант.

А>А что там народ заикался про множественный return? Разве это возможно?


Это ты о чем вообще?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[2]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 16.12.13 18:35
Оценка:
Здравствуйте, Jack128, Вы писали:

J>А в чем смысл??


В том что меньше мусорного кода.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[2]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 16.12.13 18:35
Оценка:
Здравствуйте, _NN_, Вы писали:

А>>//read only auto-properties —

А>>public int X { get; } = x;
_NN>А как это работает ?

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


_NN>Что означает "= x" ? Это инициализация или имя переменной ?


Это параметр primary constructor. Который в предыдущем примере.

А>>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

_NN>Проще разрешить выражения и убрать 'return', тогда не нужно ничего придумывать и использовать обычные свойства и методы.

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


А>>//params for enumerables —

А>>public Point Average(params IEnumerable<Point> points) { }
_NN>Я так понимаю для этого нужно менять рантайм. Верно ?

Нет. params это синтаксический сахар, рантайм менять не нужно.

А>>if (points?.FirstOrDefault()?.X ?? -1) { }

_NN>Полезная фича, давно реализуемая в других языках.

Вот только синтаксис ...

_NN>Хотя наверное только из конструктора выводит


Да.

А>>//inline declarations for out params —

А>>public void Foo(out var x, out var y) { }
_NN>Практикуют программирование на 'out' типах ?

Упрощают его.

_NN>Не проще ли кортежи добавить в язык ?


Нет.

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


Это испорченный телефон. На самом деле правильный вариант такой:
var x = Foo(out var x, out var y);
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[5]: C# 6.0
От: IT Россия linq2db.com
Дата: 16.12.13 18:39
Оценка: +5
Здравствуйте, nikov, Вы писали:

N>Скорее, это приглашение к неформальной дискуссии, чтобы лучше понять, в чём нуждаются разработчики.


Скажи честно, у тебя же у самого руки по локоть в крови AST Розлина. Неужели ты всё ещё не нуждаешься в паттерн-матчинге? ПМ ведь вам самим сэкономил бы тонны кода.
Если нам не помогут, то мы тоже никого не пощадим.
Re[3]: C# 6.0
От: Jack128  
Дата: 16.12.13 19:11
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Это испорченный телефон. На самом деле правильный вариант такой:

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

Как соотносятся x слева и справа от оператора присваивания?
Re: C# 6.0
От: Jack128  
Дата: 17.12.13 06:26
Оценка:
Здравствуйте, Аноним, Вы писали:

А>//constructor type parameter inference —

А>var t = new Tuple(1,2); // infers Tuple<T1, T2>
А как насчет "частичного" вывода типов??
что нить типа такого:
TResult Method<TArg, TResult>(TArg arg) { ... }
var s = Method<_, string>(10); // TArg вывелось как int
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 17.12.13 08:29
Оценка:
Здравствуйте, Jack128, Вы писали:

J>Как соотносятся x слева и справа от оператора присваивания?


Никак.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[3]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 17.12.13 14:34
Оценка:
Здравствуйте, AndrewVK, Вы писали:

А>>>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

_NN>>Проще разрешить выражения и убрать 'return', тогда не нужно ничего придумывать и использовать обычные свойства и методы.

AVK>Это сломает совместимость. Впрочем, кое что на эту тему, возможно, будет:

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

Можно тогда добавить какой-нибудь префикс типа
public noreturn int X { get { 1 } }



AVK>Это испорченный телефон. На самом деле правильный вариант такой:

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

Т.е. объявление переменной прямо из вызова метода ?

Может просто добавить вывод типов из использования для out.
Скажем, Nemerle:
mutable x, y;
def z = Foo(out x, out y);
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re: C# 6.0
От: Jack128  
Дата: 18.12.13 05:07
Оценка: +1
Здравствуйте, Аноним, Вы писали:

А>http://adamralph.com/2013/12/06/ndc-diary-day-3/

А>
А>//read only auto-properties - 
А>public int X { get; } = x;
А>//property expressions - 
А>public double Distance => Sqrt(X * X + Y * Y);
А>


мне кажется, что это одно и тоже.
зачем вводить синтаксис public int X { get; } = x если и так можно будет написать public int X => x; ?
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 18.12.13 12:53
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Можно тогда добавить какой-нибудь префикс


Вот так языки и превращаются в какашку

AVK>>Это испорченный телефон. На самом деле правильный вариант такой:

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

_NN>Т.е. объявление переменной прямо из вызова метода ?

Exactly. Declaration expression называется.

_NN>Может просто добавить вывод типов из использования для out.

_NN>Скажем, Nemerle:
_NN>
_NN>mutable x, y;
_NN>def z = Foo(out x, out y);
_NN>


Зачем? Смысл этой конструкции как раз в том чтобы предварительно ничего не декларировать.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[2]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 18.12.13 12:55
Оценка:
Здравствуйте, Jack128, Вы писали:

J>мне кажется, что это одно и тоже.


Кажется.

J>зачем вводить синтаксис public int X { get; } = x если и так можно будет написать public int X => x; ?


Потому что в первом случае это автосвойство, инициализируемое в конструкторе один раз, а во втором — вычисляемое при каждом обращении свойство.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: IT Россия linq2db.com
Дата: 18.12.13 13:50
Оценка:
Здравствуйте, Ikemefula, Вы писали:

I>Сильно вряд ли. Это ограничение искусственное. Процессоры Expression очевидно не умеют интерпретировать весь C#, только экспрешны. Сильно вряд ли Linq Provider будет в курсе, как интерпретировать switch или yield. Вот и обрезали до экспрешнов.


У тебя причина попутана со следствием. Linq провайдеры не интерпретируют switch, потому что генерация компилятором expressions обрезана до экспрешинов. Сделать же разбор switch не представляет особого труда. Была бы в этом необходимость.

И, кстати, yield — это сахар, ему ничего не соответствует ни в ET, ни в MSIL.
Если нам не помогут, то мы тоже никого не пощадим.
Re[5]: C# 6.0
От: hardcase Пират http://nemerle.org
Дата: 18.12.13 15:14
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Зачем? Смысл этой конструкции как раз в том чтобы предварительно ничего не декларировать.


Затем, что становится очевидной область видимости таких переменных.
/* иЗвиНите зА неРовнЫй поЧерК */
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 18.12.13 17:17
Оценка:
Здравствуйте, hardcase, Вы писали:

H>Затем, что становится очевидной область видимости таких переменных.


Вывода типов по имспользованию в C# все равно не будет.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[3]: C# 6.0
От: Sinix  
Дата: 19.12.13 05:32
Оценка:
Здравствуйте, AndrewVK, Вы писали:

J>>зачем вводить синтаксис public int X { get; } = x если и так можно будет написать public int X => x; ?

AVK>Потому что в первом случае это автосвойство, инициализируемое в конструкторе один раз, а во втором — вычисляемое при каждом обращении свойство.

Что-то пугает меня этот зоопарк. 4 варианта для описания свойства... зачем писать
public int X { get; } = x
// при наличии
public int X { get { return x; } }

?
Re[2]: C# 6.0
От: Ziaw Россия  
Дата: 19.12.13 06:14
Оценка:
Здравствуйте, _NN_, Вы писали:

А>>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

_NN>Проще разрешить выражения и убрать 'return', тогда не нужно ничего придумывать и использовать обычные свойства и методы.

Это первый шаг в сторону "все есть выражение". Похоже, что вводить такое сразу по многим причинам (в том числе неприятие разработчиков) тяжело. Это легкий вариант.
Re[4]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 19.12.13 08:23
Оценка: +1
Здравствуйте, Sinix, Вы писали:

S>Здравствуйте, AndrewVK, Вы писали:


J>>>зачем вводить синтаксис public int X { get; } = x если и так можно будет написать public int X => x; ?

AVK>>Потому что в первом случае это автосвойство, инициализируемое в конструкторе один раз, а во втором — вычисляемое при каждом обращении свойство.

S>Что-то пугает меня этот зоопарк. 4 варианта для описания свойства... зачем писать

S>
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;


Имеем значение по умолчанию, но в конструкторе можно подправить.
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[5]: C# 6.0
От: Sinix  
Дата: 19.12.13 08:40
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Это разное

_NN>Имеем значение по умолчанию, но в конструкторе можно подправить.
Ага, про поле в примере я забыл. Один фиг, синтаксис с "= x" от этого лучше не стал. Почему "= someField" означает инициализацию поля и при этом поле readonly? Даже первое пришедшее в голову
public int X { readonly x; get; }


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

Понятно, что это пока только идеи, а не то, что будет к релизу. Но явно выпадающие из привычного стиля шарпа вещи точно без обоснования вводить не следует.
Re[6]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 19.12.13 08:52
Оценка: +2
Здравствуйте, Sinix, Вы писали:


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

А зачем нужно задавать имя для поля ?
Если оно только для чтения все равно кроме конструктора менять нигде нельзя.
Достаточно, чтобы компилятор сам его подставлял в конструкторе.

S>Понятно, что это пока только идеи, а не то, что будет к релизу. Но явно выпадающие из привычного стиля шарпа вещи точно без обоснования вводить не следует.


Например Nemerle: так и так

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; }
}
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[3]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 19.12.13 09:01
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Здравствуйте, _NN_, Вы писали:


А>>>public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

_NN>>Проще разрешить выражения и убрать 'return', тогда не нужно ничего придумывать и использовать обычные свойства и методы.

Z>Это первый шаг в сторону "все есть выражение". Похоже, что вводить такое сразу по многим причинам (в том числе неприятие разработчиков) тяжело. Это легкий вариант.

Тогда это выглядит довольно разумно.
Может сделать и следующий шаг ?

var q = if(true)=> 1 else 2;
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[7]: C# 6.0
От: Sinix  
Дата: 19.12.13 09:17
Оценка:
Здравствуйте, _NN_, Вы писали:


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

_NN>А зачем нужно задавать имя для поля ?
1. В исходном синтаксисе можно
2. Для использования поля напрямую (например через ref) и навешивания атрибутов на поле.
Хотя по-моему в обоих пунктах давно пора переключиться на обычные поля и не мучать мозг.

_NN>Например Nemerle: так и так

Ага, тоже неплохо.
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 09:59
Оценка: +1
Здравствуйте, Sinix, Вы писали:

S>Что-то пугает меня этот зоопарк. 4 варианта для описания свойства... зачем писать

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


Во-втором варианте писанины несколько побольше, не находишь?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[8]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 10:05
Оценка: 26 (1)
Здравствуйте, Sinix, Вы писали:

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

_NN>>А зачем нужно задавать имя для поля ?
S>1. В исходном синтаксисе можно

Если под исходным имеется в виду "= x", то нет, нельзя. х это не имя поля, это имя параметра первичного конструктора (проблемы испорченного телефона опять). Вот так тоже можно:
public int X {get;} = CalculateX();

Чтобы было понятно — я Мэдса еще при обсуждении 3.0 пинал, что невозможно сделать readonly автосвойства. И он еще тогда был со мной полностью согласен. Но руки дошли только сейчас.

S>2. Для использования поля напрямую (например через ref)


readonly поля через ref вне конструктора нельзя использовать.

S> и навешивания атрибутов на поле.Хотя по-моему в обоих пунктах давно пора переключиться на обычные поля и не мучать мозг.


Вот именно.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[9]: C# 6.0
От: Sinix  
Дата: 19.12.13 10:09
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Если под исходным имеется в виду "= x", то нет, нельзя. х это не имя поля, это имя параметра первичного конструктора (проблемы испорченного телефона опять). Вот так тоже можно:

Ага, тогда уловил идею. Спасиб!
Re[3]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 10:16
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Это первый шаг в сторону "все есть выражение". Похоже, что вводить такое сразу по многим причинам (в том числе неприятие разработчиков) тяжело. Это легкий вариант.


Дело не в неприятии разработчиков, дело в том что C# не Немерле, и туда никто ничего не добавляет просто потому что кому то захотелось (если, конечно, захотелось не Андерсу ). Конкретно declaration expressions придумали, потому что не получается качественно добавить кортежи. Ну а фокусы типоа того, что я показал — просто побочные эффекты. Из той же оперы, кстати (оператор as is ):
if ((var y = x as SomeClass) != null)
    Foo(y);
else
  Bar();


Но таки да, дальняя цель — как можно больше конструкций сделать выражениями. Некоторые, к примеру, жаловались что нет statement формы для оператора ?:, теперь вот она есть. Еще обсуждал с Мэдсом expression форму switch (он, сктати, сказал, что и сишную бредятину с break надо выкидывать, и что как в VB позволить условия сложные писать в кейсах) — вроде бы есть какие то эксперименты (просьба воспринимать это как мои домыслы, потому что NDA) с все тем же оператором ?:, у которого может быть несколько вариантов как в switch.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 10:16
Оценка:
Здравствуйте, _NN_, Вы писали:

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


И что это должно означать?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[5]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 19.12.13 10:31
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, _NN_, Вы писали:


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


AVK>И что это должно означать?

Что тело 'then' и 'else' будет выражением а не просто блоком кода, т.е. что-то возвращает и тогда это можно будет использовать справа от присваивания
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 10:59
Оценка:
Здравствуйте, _NN_, Вы писали:

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


И чем это отличается от "true?1:2" кроме лишней писанины?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[7]: C# 6.0
От: Jack128  
Дата: 19.12.13 11:27
Оценка: +2
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, _NN_, Вы писали:


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


AVK>И чем это отличается от "true?1:2" кроме лишней писанины?


Я так понял на самом деле NN таки хочет вот этой фичи

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

http://rsdn.ru/forum/dotnet/5399449.1
Автор: AndrewVK
Дата: 16.12.13


ну и тогда можно будет писать так:


var a = true 
    ? (var x = Foo(); var y = Bar(x); FooBar(y)) 
    : (var x = FooBar(10); var y = Bar(x - 5); FooBar(y));
Re[2]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:22
Оценка: :)
Здравствуйте, adontz, Вы писали:

A>Extension properties хочу. Хотя, monadic null checking и constructor type parameter inference тоже ничего.


Так давно бы перешол на Немерл. Мы уже много лет всем этим пользуемся.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[2]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:30
Оценка:
Здравствуйте, _NN_, Вы писали:

А>>//read only auto-properties —

А>>public int X { get; } = x;
_NN>А как это работает ?
_NN>Что означает "= x" ? Это инициализация или имя переменной ?

Инициализация.

_NN>Можно ли как в Nemerle ?


Ага:

_NN>
_NN> public X : int { get; default 1 }
_NN> public Y : int { get; set; default 2 }
_NN>



А>>//params for enumerables —

А>>public Point Average(params IEnumerable<Point> points) { }
_NN>Я так понимаю для этого нужно менять рантайм. Верно ?

Зачем? Это чисто компиляторная фича. Просто вместо массива можно указать IEnumerable в params-методах.

А>>//monadic null checking —

А>>if (points?.FirstOrDefault()?.X ?? -1) { }
_NN>Полезная фича, давно реализуемая в других языках.

Можно подумать, что все остальные фичи в других языках не реализованы, или реализованы недавно .

А>>//constructor type parameter inference —

А>>var t = new Tuple(1,2); // infers Tuple<T1, T2>
_NN>Ну наконец.
_NN>Хотя наверное только из конструктора выводит, или как в Nemerle где может вывести из использования ?

Конечно, первое.

А>>//inline declarations for out params —

А>>public void Foo(out var x, out var y) { }
_NN>Практикуют программирование на 'out' типах ?
_NN>Не проще ли кортежи добавить в язык ?

Гы.

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


+1 И даже вреден (для производительности IDE). Может автор ошибся и там нельзя var использовать?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:33
Оценка:
Здравствуйте, Jack128, Вы писали:

А>>>//read only auto-properties —

А>>>public int X { get; } = x;
_NN>>А как это работает ?
_NN>>Что означает "= x" ? Это инициализация или имя переменной ?

J>x в данном случае — это поле. Обрати внимание на primary constructor выше, скорее всего как F#, его параметры в поля преобразуются.


Вопрос был не в том, что такое "x", а в том является ли это именем для поля содержащего значение свойства, или "x" — это произвольное инициализирующее значение. Думаю, второе.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:42
Оценка: +1
Здравствуйте, nikov, Вы писали:

N>...


Вы бы хоть какой-нить простенький type-switch замутили. Ну, жудко же не удобно писать в стиле:
var x = y as X;
if (x != null)
...


Про ПМ я уже молчу.

Без декомпозиции кортежей использовать их в шарпе просто противно. Казалось бы сделай:
var (a, b, c) = new Tuple(42, "a", 2.3);

И будет людям счастье. Не уж то в Розлине такое долго залудить?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:44
Оценка:
Здравствуйте, Jack128, Вы писали:

J>Правильно. По мне так дальше нужно идти, не только облегчить работу с out-параметрами, но еще и максимально усложнить работу с туплами. Чтоб даже мысли не возникало их использовать.


Они именно так и поступают.

На банальную декомпозицию кортежей у них еще 10 лет уйдет (прошлые ушли на оператор ?. и прочие приятные рюшечки). Хорошо что хоть что-то тырят из правильных идей правильных языков.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:46
Оценка:
Здравствуйте, Константин, Вы писали:

К>Проще, но хуже. У out-аргументов кроме типов есть ещё имена. У членов кортежа только типы.


На то есть записи. Это как анонимные типы, но которые можно из методов возвращать.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[2]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 12:59
Оценка:
Здравствуйте, Аноним, Вы писали:

А>>//primary constructors —

А>>public class Point(int x, int y) { }

А>Кто-нибудь может объяснить, что это? А то все читают с таким видом, будто это есть во всех языках и только c# наконец до этого докатился!


Это аналогично немерловой макре Record, но несколько более гибко, так как можно реализовать логику в кострукторе.
Фича взята из ML-семейсва. Есть в Scala, F#...

Параметры такого конструктора автоматически превращаются в поля класса. Такой конструктор может быть только один.
Если реализуют все грамотно, то тело класса при этом станет единым "скриптом" инициализации (заменой тела конструктора).

А>>using System.Math;

А>Это как в Немерле — импорт класса и вызов в коде статических методов без указания класса?

Да.

А>>//monadic null checking —

А>>if (points?.FirstOrDefault()?.X ?? -1) { }

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

А>Мрак, если откровенно.

Не скажи. Мы это в Nemerle из Groovy уже дано передрали. Очень удобно когда нужно делать много проверок на null.
Код сокращается в разы. Так что говнокод скорее без этого оператора.

Его суть очень проста. Это точка с проверкой на нул. Если выражение перед ?. вычислится в null, то выражение идущее за ?. не будет вычисляться, а будет возвращен null.
Это повзоволяет создать аналог множественного доступа к членам, но если одни из членов будет null, вместо вылета по исключению будет возвращен null, который нужно будет проверить ровно один раз.

А>А что там народ заикался про множественный return? Разве это возможно? (без хаков) Мой эксперимент на MSIL показал, что возврат из функции с более чем одним элементом на стеке сразу разрывает на куски. Т.е. "напрямую" не получится, значит опять индусские дуроломы прикрутят на изоленте hidden class, который будет прятать в себе массив возвращаемых значений.


Для этого придуманы кортежи и записи. Но до них МС будет доходить следущие 10 лет.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:01
Оценка:
Здравствуйте, nikov, Вы писали:

N>Пока что это список идей для гипотетических будущих версий C#. Некоторые из этих идей прототипировались, однако не нужно воспринимать пару слайдов на конференции как официальное объявление новых фич или как обязательство реализовать их в ближайшей следующей версии. Скорее, это приглашение к неформальной дискуссии, чтобы лучше понять, в чём нуждаются разработчики.


Что тут дискуритровать? Все эти "идеи" сто лет как реализованы в куче языков и используются на практике. Все они зарекомендовали себя очень хорошо.

Я вот только не понял, что за фигня этот ваш "=>" синтаксис при объявлении членов. Это чтобы блок с return-ом не писать?
Если да, то решение спорное. Люди для этого сто лет как используют "=".
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: C# 6.0
От: Ziaw Россия  
Дата: 19.12.13 13:06
Оценка:
Здравствуйте, AndrewVK, Вы писали:

Z>>Это первый шаг в сторону "все есть выражение". Похоже, что вводить такое сразу по многим причинам (в том числе неприятие разработчиков) тяжело. Это легкий вариант.


AVK>Дело не в неприятии разработчиков, дело в том что C# не Немерле, и туда никто ничего не добавляет просто потому что кому то захотелось (если, конечно, захотелось не Андерсу ).


Я и не называл это главной причиной. На текущий синтаксис это ляжет плохо, слишком много изменений, в том числе и ломающих обратную совместимость, для одной версии придется внести. Все равно изменения должны ложиться на привычный базис.

AVK>Конкретно declaration expressions придумали, потому что не получается качественно добавить кортежи.


Они как-то связаны или просто остались свободные ресурсы?

AVK>Ну а фокусы типоа того, что я показал — просто побочные эффекты. Из той же оперы, кстати (оператор as is ):

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


Это 6.0 или дальнейшие планы?

AVK>Но таки да, дальняя цель — как можно больше конструкций сделать выражениями. Некоторые, к примеру, жаловались что нет statement формы для оператора ?:, теперь вот она есть. Еще обсуждал с Мэдсом expression форму switch (он, сктати, сказал, что и сишную бредятину с break надо выкидывать, и что как в VB позволить условия сложные писать в кейсах) — вроде бы есть какие то эксперименты (просьба воспринимать это как мои домыслы, потому что NDA) с все тем же оператором ?:, у которого может быть несколько вариантов как в switch.


switch конечно самое вкусное, но сразу же захочется try/catch и using. Ну и иммутабельные переменные на закуску, ведь в нормальном коде большинство их станет именно такими.
Re[4]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:08
Оценка: +1
Здравствуйте, _NN_, Вы писали:

_NN>Может просто добавить вывод типов из использования для out.

_NN>Скажем, Nemerle:
_NN>
_NN>mutable x, y;
_NN>def z = Foo(out x, out y);
_NN>


Вывод типов полезен сам по себе. Но для out-параметров, действительно удобно было бы объявлять переменные прямо в параметрах. Тогда можно было бы писать как-то так:
var x = !map.TryGetValue(42, out var value) ? value : -1;
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:10
Оценка:
Здравствуйте, AndrewVK, Вы писали:

_NN>>Может просто добавить вывод типов из использования для out.

_NN>>Скажем, Nemerle:
_NN>>
_NN>>mutable x, y;
_NN>>def z = Foo(out x, out y);
_NN>>


AVK>Зачем? Смысл этой конструкции как раз в том чтобы предварительно ничего не декларировать.


Не всегда переменная нужна для out-параметров. Часто она просто по разному инициализируется в разных подветках if-ов и т.п. В шарпе очень задалбывает, что в основном можно писать var, но иногда нужно по приседать (описать тип явно).
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:15
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Вывода типов по имспользованию в C# все равно не будет.


Да, бдудет. Лет эдак через 15-20.

Я закладку на это твое сообщение поставил. Через 15 лет обсудим (если живы будем).

Вывод типов по использованию — это очень удобно. Единственная проблема — сложность алгоритмов. Но это проблема времени, а не идеологическая. А значит рано или поздно ее устранят.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:17
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Это первый шаг в сторону "все есть выражение". Похоже, что вводить такое сразу по многим причинам (в том числе неприятие разработчиков) тяжело. Это легкий вариант.


Скорее это шаг в сторону. Если бы хотели сделать "все есть выражение", то не стали бы городить отдельный синтаксис для инициализации членов, а сделали бы универсальное решение.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:22
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Дело не в неприятии разработчиков, дело в том что C# не Немерле,


+1

И это его главный недостаток.

А главное достоинство C#-а — это ReSharper!
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:24
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>И чем это отличается от "true?1:2" кроме лишней писанины?


Очевидно, тем что применимо к любой конструкции. А ?: — это хардкод.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:40
Оценка:
Здравствуйте, VladD2, Вы писали:

AVK>>Вывода типов по имспользованию в C# все равно не будет.

VD>Да, бдудет. Лет эдак через 15-20.

Только это будет уже не C#.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:40
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Не всегда переменная нужна для out-параметров. Часто она просто по разному инициализируется в разных подветках if-ов и т.п. В шарпе очень задалбывает, что в основном можно писать var, но иногда нужно по приседать (описать тип явно).


Это понятно, но тут предлагается это вместо declaration expression.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[5]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:40
Оценка:
Здравствуйте, Ziaw, Вы писали:

AVK>>Конкретно declaration expressions придумали, потому что не получается качественно добавить кортежи.

Z>Они как-то связаны или просто остались свободные ресурсы?

Связаны конечно. Туплы, применительно к шарпу, в основном, могут решить две проблемы:
1) Инлайн декларация сложного возвращаемого результата.
2) Хранение составных типов в нелокальных контейнерах.
DE решает только первую проблему, но решает ее лучше туплов, потому что у out параметров есть имена. Ну и собственно DE заменяет операцию распаковки тупла в локальные переменные.

Z>Это 6.0 или дальнейшие планы?


Я так думаю (ну ты понял, да?) что 6.0. Но пока, в отличие от первичных конструкторов и новых литералов, это все писями по воде виляно.

Z>switch конечно самое вкусное, но сразу же захочется try/catch и using.


Ну, цель то заявлена именно в разумно полном покрытии всех конструкций. Просто свитч больше всего напрягает лично меня.

Z> Ну и иммутабельные переменные на закуску, ведь в нормальном коде большинство их станет именно такими.


В локальном контексте не так критично. Я только обратил внимание, что неплохо бы добавить вывод типов для локальных констант. Можно заодно расширить их семантику до ro переменных, все равно наружу оно не смотрит и в сборке не фиксируется никак.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[3]: C# 6.0
От: Ziaw Россия  
Дата: 19.12.13 13:44
Оценка:
Здравствуйте, VladD2, Вы писали:

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


Ты имеешь в виду другой конструктор?
Re[3]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:47
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Это сломает совместимость. Впрочем, кое что на эту тему, возможно, будет:

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


А зачем в круглых то скобках, а не в фигурных?
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:52
Оценка:
Здравствуйте, VladD2, Вы писали:

AVK>>И чем это отличается от "true?1:2" кроме лишней писанины?

VD>Очевидно, тем что применимо к любой конструкции.

Ну так если сделать любую конструкцию выражением, то получится то же самое, вид в профиль.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:52
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>И будет людям счастье. Не уж то в Розлине такое долго залудить?


Говорят, долго. Хорошо хоть прямо не посылают, как раньше. Хотя, казалось бы, при наличии первичного конструктора и определенных ограничениях на внутренности уже никаких discriminated unions добавлять в язык не нужно, связь между параметрами и свойствами и так формально определена. Но, пока, увы.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:52
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Вопрос был не в том, что такое "x", а в том является ли это именем для поля содержащего значение свойства, или "x" — это произвольное инициализирующее значение. Думаю, второе.


Это испорченный телефон. Исходный пример такой:
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);
}
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:54
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Только это будет уже не C#.


Ну, если только он сдохнет или сдохнет МС.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:54
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А зачем в круглых то скобках, а не в фигурных?


Это не финальный синтаксис.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 13:54
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Я вот только не понял, что за фигня этот ваш "=>" синтаксис при объявлении членов. Это чтобы блок с return-ом не писать?


Да. Методов это тоже касается.

VD>Если да, то решение спорное. Люди для этого сто лет как используют "=".


Конфликтует с инициализацией.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 13:55
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Это понятно, но тут предлагается это вместо declaration expression.


Вот я и говорю, что одно другому не мешает. Понятно, что крутой вывод типов по использованию МС сейчас не потяент. Но лет за 10 они вполне его могут сделать на должном уровне.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: C# 6.0
От: Евгений Акиньшин grapholite.com
Дата: 19.12.13 14:01
Оценка:
Здравствуйте, VladD2, Вы писали:


VD>Без декомпозиции кортежей использовать их в шарпе просто противно. Казалось бы сделай:

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


А зачем это нужно в таком виде? Все равно ведь непонятно, что в результате вернется. Лучше уж в специальную структурку завернуть результат.

Я бы предпочел, чтобы из анонимных типов можно было результат функции формировать, типа

public var F()
{
  return new { Name = "A", Age = 10 };
}
Не шалю, никого не трогаю, починяю примус Diagrams Designer for iPad and Windows 10
Re[6]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 14:01
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>DE решает только первую проблему, но решает ее лучше туплов, потому что у out параметров есть имена. Ну и собственно DE заменяет операцию распаковки тупла в локальные переменные.


Хреново он ее решает. Неудобно. Лучше бы довели до ума анонимные типы. Сделали бы синтаксисх их декларации по месту, как у записей в ML-е. Например:
<int a; string b;> Foo()
{
  return new { a=42, b="text" };
}


AVK>В локальном контексте не так критично. Я только обратил внимание, что неплохо бы добавить вывод типов для локальных констант. Можно заодно расширить их семантику до ro переменных, все равно наружу оно не смотрит и в сборке не фиксируется никак.


А я как сейчас помню восторженную презентацию C# (1.0) в которой рассказывалось о необходимости указывать тип у констант, как о невероятном достоинстве.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 14:03
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Ну так если сделать любую конструкцию выражением, то получится то же самое, вид в профиль.


Придется сдублировать все конструкции языка.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 19.12.13 14:07
Оценка:
Здравствуйте, Евгений Акиньшин, Вы писали:

ЕА>А зачем это нужно в таком виде? Все равно ведь непонятно, что в результате вернется. Лучше уж в специальную структурку завернуть результат.


ЕА>Я бы предпочел, чтобы из анонимных типов можно было результат функции формировать, типа


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


А как знать что внутри при вызове метода ?
Уже сейчас можно вернуть object/dynamic и вперед.
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 14:10
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Говорят, долго. Хорошо хоть прямо не посылают, как раньше.


Это — да. Это большой пробгресс. Глядишь к 8-ке таки урезанный ПМ выкатят, как в Котлине. И на шарпе можно будет программировать без мата вырывания волос на заднице.

AVK>Хотя, казалось бы, при наличии первичного конструктора и определенных ограничениях на внутренности уже никаких discriminated unions добавлять в язык не нужно, связь между параметрами и свойствами и так формально определена. Но, пока, увы.


Тут две проблемы. Одна, как ты верно заметил, связь между полями и параметрами конструктора. Вторая — это описание фиксированных иерархий.

Дело в том, что основной проблемой ПМ по классам является проблема неучтенных расширений (подтипов). Написал ты проверку, а потом добавил еще класс (возможно в другой сборке) и вот у тебя уже потенциальная ошибка в рантайме. Замкнутость алгебраических типов дает контроль над этим делом. Но тут можно sealed использовать. Кривовато, но работать будет.

А вообще, ПМ прекрасно работает и без соответствия параметров и полей. Получается чуть более громоздко, но все же удобнее ифов.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[3]: C# 6.0
От: adontz Грузия http://adontz.wordpress.com/
Дата: 19.12.13 14:56
Оценка:
Здравствуйте, VladD2, Вы писали:

A>>Extension properties хочу. Хотя, monadic null checking и constructor type parameter inference тоже ничего.

VD>Так давно бы перешол на Немерл. Мы уже много лет всем этим пользуемся.

Я на работе с боями пропихиваю Т4 Фантазёр вы, батенька.
A journey of a thousand miles must begin with a single step © Lau Tsu
Re[8]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:00
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Дело в том, что основной проблемой ПМ по классам является проблема неучтенных расширений (подтипов).


Это проблема далеко не только ПМ. Те же визиторы или мультиметоды от нее страдают в полный рост.

VD>Но тут можно sealed использовать. Кривовато, но работать будет.


Тут, скорее, надо просто ввести ключевое слово типа static, которое одновременно и sealed добавит и запретит создание свойств, которые ПМ обработать не сможет.

VD>А вообще, ПМ прекрасно работает и без соответствия параметров и полей.


В этом случае контроля становится существенно меньше.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[10]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:00
Оценка: +1
Здравствуйте, VladD2, Вы писали:

AVK>>Ну так если сделать любую конструкцию выражением, то получится то же самое, вид в профиль.

VD>Придется сдублировать все конструкции языка.

Да. Впрочем, в случае if начало уже положено .
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[7]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:00
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Хреново он ее решает. Неудобно. Лучше бы довели до ума анонимные типы. Сделали бы синтаксисх их декларации по месту


Это было бы, вне всяких сомнений, лучше.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:01
Оценка:
Здравствуйте, adontz, Вы писали:

A>Я на работе с боями пропихиваю Т4


Надо уже с боями вместо Т4 пропихивать Razor
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 15:06
Оценка:
Здравствуйте, AndrewVK, Вы писали:

VD>>Если да, то решение спорное. Люди для этого сто лет как используют "=".


AVK>Конфликтует с инициализацией.


Этот вариант, заметь, еще и тучу вопросов вызывает.

А меж тем все вроде как довольно просто.

Для полей этой проблемы не стоит, так как они только инициализируются.

Для свойств можно использовать синтаксис:
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;
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 15:11
Оценка: 6 (1) +1
Здравствуйте, Евгений Акиньшин, Вы писали:

ЕА>А зачем это нужно в таком виде? Все равно ведь непонятно, что в результате вернется.


Непонятно это только теоретикам. У практиков проблем с пониманием не возникает.

ЕА>Лучше уж в специальную структурку завернуть результат.


Одно другого не отменяет. Иногда нужно по быстрому кортеж сваять, иногда нужно ясности придать, тут уже записи (описываемые анонимные типы) рулят.

ЕА>Я бы предпочел, чтобы из анонимных типов можно было результат функции формировать, типа


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


Это не разумное предложение. Оно быстро сломает интелисенс в больших проектах. В методе может быть 100500 выражений, и методов может быть 100500. Для вывода типов придется протипизировать все их тела. А это самая долгая операция. Решарпер даже не парсит тела методов до того как пользователь к ним не обратится. А ты предлагаешь их все типизировать.

Правильное решение для языка с хорошей поддержкой IDE будет возможность декларировать анонимные типы (превращение их в записи):
public <string Name, int Age> F()
{
  return new { Name = "A", Age = 10 };
}
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: C# 6.0
От: adontz Грузия http://adontz.wordpress.com/
Дата: 19.12.13 15:11
Оценка:
Здравствуйте, AndrewVK, Вы писали:

A>>Я на работе с боями пропихиваю Т4

AVK>Надо уже с боями вместо Т4 пропихивать Razor

Ты предалагешь SQL генерировать с помошью Razor? Все эти @Parameters? Не, спасибо.
A journey of a thousand miles must begin with a single step © Lau Tsu
Re[4]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 15:12
Оценка:
Здравствуйте, adontz, Вы писали:

A>Я на работе с боями пропихиваю Т4 Фантазёр вы, батенька.


Надо стараться.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 15:15
Оценка:
Здравствуйте, AndrewVK, Вы писали:

VD>>Дело в том, что основной проблемой ПМ по классам является проблема неучтенных расширений (подтипов).


AVK>Это проблема далеко не только ПМ. Те же визиторы или мультиметоды от нее страдают в полный рост.


У шаблона Посетитель такой проблемы нет. Там интерфейс определяет список альтернатив. А у мультиметодов вообще проблем хватает. Их и реализовать эффективно сложно, и с защитой проблемы. Но, зато, они расширяемые извне.

AVK>Тут, скорее, надо просто ввести ключевое слово типа static, которое одновременно и sealed добавит и запретит создание свойств, которые ПМ обработать не сможет.


Про статик не понял.

VD>>А вообще, ПМ прекрасно работает и без соответствия параметров и полей.


AVK>В этом случае контроля становится существенно меньше.


Ты не прав. Это не связанные проблемы. Тот же sealed решает проблему закрытости списка альтернатив.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 19.12.13 15:16
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Надо уже с боями вместо Т4 пропихивать Razor


Сдается мне, что как мета-тул он будет мало интересен. Разве что как довесок к тому же Т4.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: C# 6.0
От: Ikemefula Беларусь http://blogs.rsdn.org/ikemefula
Дата: 19.12.13 15:17
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Я вот только не понял, что за фигня этот ваш "=>" синтаксис при объявлении членов. Это чтобы блок с return-ом не писать?

VD>Если да, то решение спорное. Люди для этого сто лет как используют "=".

Да, C# это не Немерле и никогда, слава богу, им не будет.

В С# с первой версии = для присваивания. => уже используется для лямбд, что бы блок с ретурном не писать. Так что всё очевидно
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:39
Оценка:
Здравствуйте, adontz, Вы писали:

A>Ты предалагешь SQL генерировать с помошью Razor?


Да.

A>Все эти @Parameters? Не, спасибо.


На Т4 мусора все равно будет больше. Ну и вместо @ там вроде ? можно.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[6]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:39
Оценка:
Здравствуйте, VladD2, Вы писали:

AVK>>Надо уже с боями вместо Т4 пропихивать Razor

VD>Сдается мне, что как мета-тул он будет мало интересен.

Почему?

VD> Разве что как довесок к тому же Т4.


Вот уж как довесок к Т4 он точно не нужен.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[10]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 19.12.13 15:39
Оценка:
Здравствуйте, VladD2, Вы писали:

AVK>>Это проблема далеко не только ПМ. Те же визиторы или мультиметоды от нее страдают в полный рост.


VD>У шаблона Посетитель такой проблемы нет. Там интерфейс определяет список альтернатив.


Определять то определяет, но никак не запрещает подсунуть любого наследника. Точно такую же схему можно и в ПМ реализовать.

AVK>>Тут, скорее, надо просто ввести ключевое слово типа static, которое одновременно и sealed добавит и запретит создание свойств, которые ПМ обработать не сможет.


VD>Про статик не понял.


Ну есть такое ключевое слово static, которое навешивает sealed и запрещает нестатические члены.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[8]: C# 6.0
От: Евгений Акиньшин grapholite.com
Дата: 19.12.13 15:48
Оценка:
Здравствуйте, VladD2, Вы писали:

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


VD>Это не разумное предложение. Оно быстро сломает интелисенс в больших проектах. В методе может быть 100500 выражений, и методов может быть 100500. Для вывода типов придется протипизировать все их тела. А это самая долгая операция. Решарпер даже не парсит тела методов до того как пользователь к ним не обратится. А ты предлагаешь их все типизировать.


VD>Правильное решение для языка с хорошей поддержкой IDE будет возможность декларировать анонимные типы (превращение их в записи):

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


Согласен, так меня тоже вполне устроит.
Не шалю, никого не трогаю, починяю примус Diagrams Designer for iPad and Windows 10
Re[4]: C# 6.0
От: Ziaw Россия  
Дата: 20.12.13 01:44
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Скорее это шаг в сторону. Если бы хотели сделать "все есть выражение", то не стали бы городить отдельный синтаксис для инициализации членов, а сделали бы универсальное решение.


Там не только инициализация, но и тело метода может быть.
Re[7]: C# 6.0
От: Jack128  
Дата: 20.12.13 10:13
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Хреново он ее решает. Неудобно. Лучше бы довели до ума анонимные типы. Сделали бы синтаксисх их декларации по месту, как у записей в ML-е. Например:

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


А такие типы между сборок должны шарится?
Re[8]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 12:41
Оценка:
Здравствуйте, Jack128, Вы писали:

J>А такие типы между сборок должны шарится?


Не то чтобы "шариться". Их в рантайме нужно поддерживать. Для них должна быть реализована структурная эквивалентность. Тип объявленный в одной сборке должен быть совместим с таким же типом из другой сборки. Еще имеет смысл явное приведение сделать с кортежами и типами эквивалентными структурно, но имеющими другие названия полей.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: C# 6.0
От: Jack128  
Дата: 20.12.13 12:48
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, Jack128, Вы писали:


J>>А такие типы между сборок должны шарится?


VD>Не то чтобы "шариться". Их в рантайме нужно поддерживать. Для них должна быть реализована структурная эквивалентность. Тип объявленный в одной сборке должен быть совместим с таким же типом из другой сборки. Еще имеет смысл явное приведение сделать с кортежами и типами эквивалентными структурно, но имеющими другие названия полей.


Хе. Структурная эквивалентность в .NET ?? Что то не верится -)
Re[5]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 12:57
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Там не только инициализация, но и тело метода может быть.


Ну, вот и нужно было для тела выбрать "=", а инициализацию как-то по другому сделать.

Собственно мы так и сделали. NN по началу тоже хотел вариант
X : int { get; } = 42;

выбрать. Но мы подумали и решили, что это чревато проблемами.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 13:00
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Определять то определяет, но никак не запрещает подсунуть любого наследника. Точно такую же схему можно и в ПМ реализовать.


А причем тут наследники? Наследник будет переопределять поведение, но ты не сможешь вызвать Посетителя, если некоторое методы не реализованы, а с ПМ на открытых иерархиях это сделать элементарно. Иногда это даже бывает полезно. Но контроль понижается.

AVK>>>Тут, скорее, надо просто ввести ключевое слово типа static, которое одновременно и sealed добавит и запретит создание свойств, которые ПМ обработать не сможет.


VD>>Про статик не понял.


AVK>Ну есть такое ключевое слово static, которое навешивает sealed и запрещает нестатические члены.


А причем тут оно? Оно тут никаким боком.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 13:07
Оценка:
Здравствуйте, AndrewVK, Вы писали:

VD>>Сдается мне, что как мета-тул он будет мало интересен.


AVK>Почему?


1. Нерасширяем. Поддерживает только шарп и васик.
2. Заточен на языковый сервис в IDE и компилятор.
3. Не позволяет вмешиваться в процесс парсинга/типизации.
4. Не имеет никаких средств ни для декомпозиции, ни для композиции кода.

Единственное его применение — это получение метаинформации о коде шарпа. Это очень узкая ниша. В реальных задачах придется сделать еще 100500 приседаний.

VD>> Разве что как довесок к тому же Т4.


AVK>Вот уж как довесок к Т4 он точно не нужен.


Ну, почему же? Т4 позволяет худо-бедно автоматизировать генерацию кода. Розлин — получить информацию о коде из проекта. Соединяем их вместе и получаем более интеллектуальную систему генерации кода, для тех кто боится использовать Немерл .
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: C# 6.0
От: Sinix  
Дата: 20.12.13 13:12
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Не то чтобы "шариться". Их в рантайме нужно поддерживать. Для них должна быть реализована структурная эквивалентность. Тип объявленный в одной сборке должен быть совместим с таким же типом из другой сборки.


С структурной эквивалентностью вылазят проблемы с рефлексией (начиная c type.AssemblyQualifiedName), сериализацией и с xml-комментариями. Решить можно, но я не уверен что затраты соответствуют выигрышу. Если уж передавать тип за границы сборки, то лучше объявить его явно и не возиться с "добавили поле в результат метода в сборке А -> всё упало в B".
Re[7]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 13:29
Оценка:
Здравствуйте, Ikemefula, Вы писали:

I>Да, C# это не Немерле и никогда, слава богу, им не будет.


I>В С# с первой версии = для присваивания. => уже используется для лямбд, что бы блок с ретурном не писать. Так что всё очевидно


Для тебя. Но тут дело в тебе.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: C# 6.0
От: Ikemefula Беларусь http://blogs.rsdn.org/ikemefula
Дата: 20.12.13 14:04
Оценка:
Здравствуйте, VladD2, Вы писали:

I>>Да, C# это не Немерле и никогда, слава богу, им не будет.


I>>В С# с первой версии = для присваивания. => уже используется для лямбд, что бы блок с ретурном не писать. Так что всё очевидно


VD>Для тебя. Но тут дело в тебе.


Не льсти себе — это вызывает слепоту.
Re[10]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 18:31
Оценка:
Здравствуйте, Jack128, Вы писали:

J>Хе. Структурная эквивалентность в .NET ?? Что то не верится -)


А какие проблемы?

Они ее даже реализовали, но только для отдельных типов данных, для улучшения поддержки COM-а.

С точки зрения компьютера никаких типов данных не существует. Есть только области памяти. А типы данных — это их интерпретация. Структурная эквивалентность — это не более чем возможность использовать один "объект" вместо другого. МС без проблем может залудить это дело как только на то появится "политическая" воля.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 18:39
Оценка:
Здравствуйте, Sinix, Вы писали:

S>С структурной эквивалентностью вылазят проблемы с рефлексией (начиная c type.AssemblyQualifiedName), сериализацией и с xml-комментариями.


Эти смелые утверждения нужно как следует обосновать. Я вот никаких проблем не вижу.

S>Решить можно, но я не уверен что затраты соответствуют выигрышу.


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

Проверка структурной эквивалентности типов производится в момент загрузки сборок/типов. Далее для нужд рефлексии и т.п. используем первый попавшийся тип, а остальные позволяет передавать там где ожидаются их структурные эквиваленты.

S>Если уж передавать тип за границы сборки, то лучше объявить его явно и не возиться с "добавили поле в результат метода в сборке А -> всё упало в B".


Это физически невозможно. Будет "брильянтовая проблема". В одной библиотеке объявляем тип. Другой объявляем тот же тип. Что делать приложению которое хочет использовать обе библиотеки и этот тип? Единственный выход — объявить свой тип, проверить, что он структурно эквивалентен двум других типам из других сборок и позволить использовать один тип вместо другого.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 20.12.13 18:40
Оценка:
Здравствуйте, Ikemefula, Вы писали:

I>Не льсти себе — это вызывает слепоту.


Я то тут причем? Ты уж как-нить со своей слепотой сам разбирайся.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: C# 6.0
От: Ikemefula Беларусь http://blogs.rsdn.org/ikemefula
Дата: 21.12.13 06:10
Оценка:
Здравствуйте, VladD2, Вы писали:

I>>Не льсти себе — это вызывает слепоту.


VD>Я то тут причем? Ты уж как-нить со своей слепотой сам разбирайся.


А кто по твоему, не видит что = это присваивание ?
Re[8]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 21.12.13 15:08
Оценка: :)
Здравствуйте, VladD2, Вы писали:

VD>1. Нерасширяем. Поддерживает только шарп и васик.


Пфф.

VD>2. Заточен на языковый сервис в IDE и компилятор.


Нет.

VD>3. Не позволяет вмешиваться в процесс парсинга/типизации.


Т4 тоже не позволяет.

VD>4. Не имеет никаких средств ни для декомпозиции, ни для композиции кода.


Имеет.

VD>Единственное его применение — это получение метаинформации о коде шарпа.


Ты, видимо, о чем то о своем, а не про razor.

AVK>>Вот уж как довесок к Т4 он точно не нужен.

VD>Ну, почему же? Т4 позволяет худо-бедно автоматизировать генерацию кода. Розлин — получить информацию о коде из проекта.

Ну понятно, как обычно читаем по диагонали. Не розлин, а razor.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[8]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 21.12.13 15:11
Оценка:
Здравствуйте, Jack128, Вы писали:

J>А такие типы между сборок должны шарится?


Обязательно. И в этот то проблема — такие типы нужно протаптывать в CLR, причем с изменением метаданных. Последний раз метаданные менялись в далеком 2004, так что ...
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 21.12.13 17:43
Оценка: :)
Здравствуйте, AndrewVK, Вы писали:

AVK>Пфф.

AVK>Нет.
AVK>Т4 тоже не позволяет.
AVK>Имеет.

Голословные заявления и утверждения в стиле КО меня не интересуют.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 22.12.13 14:22
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Голословные заявления заявления и утверждения в стиле КО меня не интересуют.


Т.е. ты опять прочел по диагонали и почти ничего не понял.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 22.12.13 17:08
Оценка: 7 (1)
Здравствуйте, AndrewVK, Вы писали:

J>>А такие типы между сборок должны шарится?


AVK>Обязательно. И в этот то проблема — такие типы нужно протаптывать в CLR, причем с изменением метаданных. Последний раз метаданные менялись в далеком 2004, так что ...


Это не верные утверждения.

"Шарить" ничего не надо, даже вредно. Нужно соглашение по которому фреймворк будет считать типы одинаковыми и позволять передавать один вместо другого.

В метаданных нужно всего лишь отразить факт того что тип рассматривается как структурно эквивалентный. Это можно сделать даже простым атрибутом.

Вот что должно измениться, так это поведение фремворка. Но тут проблем возникнуть не должно.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 22.12.13 17:11
Оценка: :)
Здравствуйте, AndrewVK, Вы писали:

AVK>Т.е. ты опять прочел по диагонали и почти ничего не понял.


Если тебе приятно считать себя умнее других — считай. Мне все равно.

Если же хочешь нормальной дискуссии, потрудись аргументировать свои утверждения. Я не мальчик на "нет" отвечать — "да", и т.п.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[9]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 22.12.13 22:09
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Ну понятно, как обычно читаем по диагонали. Не розлин, а razor.


А ты это сразу не понял? Очевидная же описка.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: C# 6.0
От: Sinix  
Дата: 23.12.13 06:38
Оценка:
Здравствуйте, VladD2, Вы писали:

S>>С структурной эквивалентностью вылазят проблемы с рефлексией (начиная c type.AssemblyQualifiedName), сериализацией и с xml-комментариями.

VD>Эти смелые утверждения нужно как следует обосновать. Я вот никаких проблем не вижу.

Проблемы решаются и даже несколькими способами, но каждый из вариантов порождает новые. Для начала, что должен вывести:
// Assembly 1
/// <returns>
/// Тип 1
/// </returns>
public var F() // Кстати, а как передавать такой тип через параметры?
{
  return new { Name = "A", Age = 10 };
}

// Assembly 2
/// <returns>
/// Тип 2
/// </returns>
public var F2()
{
  return new { Name = "B", Age = 11 };
}

var a = F();
var t = a.GetType();
a = F2();
var t2 = a.GetType();

Console.WriteLine(t == t2);

?
Тут какой вариант не выбери — будут свои косяки.

Кстати, какую подсказку должна показывать студия при наведении на a — "Тип 1", или "Тип 2"?


S>>Решить можно, но я не уверен что затраты соответствуют выигрышу.

VD>Нет там никаких особых затрат. И дотнет уже поддерживает ограниченную структурную эквивалентность для комовских типов.
Если ничего не путаю, она сводится к динамичесмкому маппингу к заданному интерфейсу, т.е. это не совсем структурная эквивалентность.

VD>Проверка структурной эквивалентности типов производится в момент загрузки сборок/типов. Далее для нужд рефлексии и т.п. используем первый попавшийся тип, а остальные позволяет передавать там где ожидаются их структурные эквиваленты.


Ага, это один из вариантов. У него три проблемы:
1. Сразу идёт лесом сериализация, т.к. типы исходного и десериализованного значений могут отличаться.
2. Замедляется загрузка сборок из-за проверки на эквивалентность типов.
3. Непредсказуемо ломается биндинг и прочие методы, завязанные на рефлексию. Например, Attribute.IsDefined() — атрибут-то можно навесить только на один из типов. Или завязка на по полное имя типа/его guid. Причём упасть оно может не на тестах, а уже в продакшне, например, из-за изменившейся логики ngen.

S>>Если уж передавать тип за границы сборки, то лучше объявить его явно и не возиться с "добавили поле в результат метода в сборке А -> всё упало в B".

VD>Это физически невозможно. Будет "брильянтовая проблема". В одной библиотеке объявляем тип. Другой объявляем тот же тип. Что делать приложению которое хочет использовать обе библиотеки и этот тип?
Это будут два разных типа, поскольку они объявлены в разных библиотеках. И то, что они _сейчас_ совпадают вплоть до имён-типов полей не даёт никаких гарантий, что так будет и в будущем.

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

Такие вещи нестрашны для мелких проектов. Для энтерпрайза, где типовое требование "чтоб работало на произвольной версии и не падало после обновлений" оно не подходит.
Re[12]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 23.12.13 07:10
Оценка:
Здравствуйте, Sinix, Вы писали:

S>>>Решить можно, но я не уверен что затраты соответствуют выигрышу.

VD>>Нет там никаких особых затрат. И дотнет уже поддерживает ограниченную структурную эквивалентность для комовских типов.
S>Если ничего не путаю, она сводится к динамичесмкому маппингу к заданному интерфейсу, т.е. это не совсем структурная эквивалентность.
Да, речь о структурной эквивалентности типов.

VD>>Проверка структурной эквивалентности типов производится в момент загрузки сборок/типов. Далее для нужд рефлексии и т.п. используем первый попавшийся тип, а остальные позволяет передавать там где ожидаются их структурные эквиваленты.


S>Ага, это один из вариантов. У него три проблемы:

S>1. Сразу идёт лесом сериализация, т.к. типы исходного и десериализованного значений могут отличаться.
А разве анонимные типы сериализуются?
S>2. Замедляется загрузка сборок из-за проверки на эквивалентность типов.
Не думаю что значительно
S>3. Непредсказуемо ломается биндинг и прочие методы, завязанные на рефлексию. Например, Attribute.IsDefined() — атрибут-то можно навесить только на один из типов. Или завязка на по полное имя типа/его guid. Причём упасть оно может не на тестах, а уже в продакшне, например, из-за изменившейся логики ngen.
Даже не представляю, как вешать атрибуты на анонимные типы.
Re[13]: C# 6.0
От: Sinix  
Дата: 23.12.13 07:55
Оценка:
Здравствуйте, samius, Вы писали:

S>А разве анонимные типы сериализуются?

Зависит от сериализатора. Из штатных — JavaScriptSerializer умел кажется.
Сейчас это в принципе неважно, анонимные типы как правило не выходят за границы метода. Но если нужно превратить их в полноценно используемые типы — нужна и поддержка сериализации.

S>>2. Замедляется загрузка сборок из-за проверки на эквивалентность типов.

S>Не думаю что значительно
Напомню, исходный пойнт был "Нет там никаких особых затрат" В лучшем случае получается hash match с последующей проверкой типов с совпадающими хешами. Если анонимные типы вложенные — всё становится заметно веселее.

S>Даже не представляю, как вешать атрибуты на анонимные типы.

Полноценная структурная эквивалентность подразумевает, что типы могут быть и неанонимными. Если ограничивать только ими, то пользы от структурной эквивалентности мало. Например, как передавать анонимный тип в параметры метода? Прописывать сигнатуру?

Там дело не только в атрибутах — придётся искать проблемные места в TypeDescriptor, CustomReflectionContext, сериализаторах и т.д. и т.п.

И всё это из-за того, что пользователь ленится написать
class A { public int X; public string Y; }

?
Re[12]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 23.12.13 09:01
Оценка:
Здравствуйте, VladD2, Вы писали:

AVK>>Т.е. ты опять прочел по диагонали и почти ничего не понял.

VD>Если тебе приятно считать себя умнее других — считай.

А если нет?

VD>Если же хочешь нормальной дискуссии, потрудись аргументировать свои утверждения


Чтобы была нормальная дисскуссия собеседник, как минимум, должен читать твои сообщения.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[10]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 23.12.13 09:01
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>А ты это сразу не понял? Очевидная же описка.


Ну раз описка, то можно тогда пояснить, каким образом разор:
1) Заточен на языковой сервис в IDE и компиляторе?
2) Почему хелперы и лейауты не являются средством декомпозиции?
3) Каким образом он помогает "получать метаинформацию о коде шарпа"?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[14]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 23.12.13 10:00
Оценка:
Здравствуйте, Sinix, Вы писали:

S>Здравствуйте, samius, Вы писали:


S>Зависит от сериализатора. Из штатных — JavaScriptSerializer умел кажется.

S>Сейчас это в принципе неважно, анонимные типы как правило не выходят за границы метода. Но если нужно превратить их в полноценно используемые типы — нужна и поддержка сериализации.
Если бы это было справедливо для всех типов, покидающих границы метода, то я бы согласился с тем что это было бы обязательной фичей.

S>Напомню, исходный пойнт был "Нет там никаких особых затрат" В лучшем случае получается hash match с последующей проверкой типов с совпадающими хешами. Если анонимные типы вложенные — всё становится заметно веселее.

Мне кажется что нас совершенно не должна беспокоить вложенность анонимных типов. Можно их все считать никуда не вложенными.

S>>Даже не представляю, как вешать атрибуты на анонимные типы.

S>Полноценная структурная эквивалентность подразумевает, что типы могут быть и неанонимными. Если ограничивать только ими, то пользы от структурной эквивалентности мало. Например, как передавать анонимный тип в параметры метода? Прописывать сигнатуру?
На сколько я понял, речь не идет о полноценной структурной эквивалентности всех типов в общем случае и анонимных и не анонимных типов в частности. Это поломает типизацию совершенно полностью. Этакий глобальный дак-тайпинг, где ни один метод не сможет гарантировать то что он принимает совершенно конкретный тип. Ему придется принимать все структурно-эквивалентное.
Потому уверен что обсуждается структурная эквивалентность только анонимных типов.

S>Там дело не только в атрибутах — придётся искать проблемные места в TypeDescriptor, CustomReflectionContext, сериализаторах и т.д. и т.п.

А это не про анонимные типы.
Re[15]: C# 6.0
От: Sinix  
Дата: 23.12.13 11:57
Оценка:
Здравствуйте, samius, Вы писали:

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

S>Если бы это было справедливо для всех типов, покидающих границы метода, то я бы согласился с тем что это было бы обязательной фичей.
Ок, сформулируем так:
* для обычных типов "добавить сериализацию" означает "добавить сериализацию в объявление типа".
* для анонимных типов — "выкинуть нафиг и переписать на нормалььные типы".

Причём к "выкинуть нафиг" рано или поздно сводится почти всё, начиная с "добавить ещё одно поле к результату". Ну и зачем связываться?

S>>Напомню, исходный пойнт был "Нет там никаких особых затрат" В лучшем случае получается hash match с последующей проверкой типов с совпадающими хешами. Если анонимные типы вложенные — всё становится заметно веселее.

S>Мне кажется что нас совершенно не должна беспокоить вложенность анонимных типов. Можно их все считать никуда не вложенными.
Речь про вот это:
var y = new A
{
    X = new 
    {
        A = "123", B = 456
    },
    Y = new 
    {
        A = "789", B = 123
    },
    Z = Assembly2.NewAB("112", 453)
};


X, Y, Z должны быть признаны структурно эквивалентными. В ту же степь — финты вида
var MyMeth(int i)
{
    return i <= 0?
        null :
        new
        {
            I = i,
            Next = MyMeth(i-1)
        };
}


S>На сколько я понял, речь не идет о полноценной структурной эквивалентности всех типов в общем случае и анонимных и не анонимных типов в частности. Это поломает типизацию совершенно полностью. Этакий глобальный дак-тайпинг, где ни один метод не сможет гарантировать то что он принимает совершенно конкретный тип. Ему придется принимать все структурно-эквивалентное.

S>Потому уверен что обсуждается структурная эквивалентность только анонимных типов.
Тогда совсем неинтересно. Первая же проблема: как инстанс анонимного типа передать через параметр?

S>>Там дело не только в атрибутах — придётся искать проблемные места в TypeDescriptor, CustomReflectionContext, сериализаторах и т.д. и т.п.

S>А это не про анонимные типы.
Про них. Потому что у нас всё вышеперечисленное может работать с анонимными типами. И ждать косяков от
var x = new { A = 123 };
dynamic y = x;
WriteLine(y.A);

или от
var x = new { A = 123 };
x.GetType().Assembly;

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

Конечно, есть альтернативный вариант: для всех структурно эквивалентных анонимных типов в рантайме генерится анонимный тип, прописанный в mscorlib, но там тоже есть свои неоднозначности.
Ну и VladD2 предложил именно вариант с подменой на первый попавшийся совместимый тип — его и обсуждаем пока.
Re[13]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 23.12.13 12:04
Оценка: -1 :)
Здравствуйте, AndrewVK, Вы писали:

AVK>Чтобы была нормальная дисскуссия собеседник, как минимум, должен читать твои сообщения.


Кажись понял о чем ты. Сори, действительно, попутал. Но можно было бы не выпендриваться, а сразу сказать.

Что до Разор вс. Т4, то это замена шыла на мыло.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[14]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 23.12.13 12:39
Оценка: +2
Здравствуйте, VladD2, Вы писали:

VD>Но можно было бы не выпендриваться, а сразу сказать.


Ты, видимо, о чем то о своем, а не про razor.
...
Не розлин, а razor.


VD>Что до Разор вс. Т4, то это замена шыла на мыло.


Если оставить за скобками жутко избыточный синтаксис Т4, то может быть. Но если не шашечки а ехать, то разор сильно удобнее.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[16]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 23.12.13 12:42
Оценка:
Здравствуйте, Sinix, Вы писали:

S>Здравствуйте, samius, Вы писали:


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

S>>Если бы это было справедливо для всех типов, покидающих границы метода, то я бы согласился с тем что это было бы обязательной фичей.
S>Ок, сформулируем так:
S>* для обычных типов "добавить сериализацию" означает "добавить сериализацию в объявление типа".
S>* для анонимных типов — "выкинуть нафиг и переписать на нормалььные типы".
Да, думаю что это приемлемо.

S>Причём к "выкинуть нафиг" рано или поздно сводится почти всё, начиная с "добавить ещё одно поле к результату". Ну и зачем связываться?

не понял. Для того что бы добавить еще одно или 10 полей к результату, выкидывать не надо.
А связываемся мы с этим затем, что бы мы могли делать объявления методов, совместимые с анонимными типами. Linq-у это здорово поможет.

S>>Мне кажется что нас совершенно не должна беспокоить вложенность анонимных типов. Можно их все считать никуда не вложенными.

S>Речь про вот это:
S>
S>var y = new A
S>{
S>    X = new 
S>    {
S>        A = "123", B = 456
S>    },
S>    Y = new 
S>    {
S>        A = "789", B = 123
S>    },
S>    Z = Assembly2.NewAB("112", 453)
S>};
S>

Я не вижу здесь причин для того что бы делать типы вложенными.

S>X, Y, Z должны быть признаны структурно эквивалентными. В ту же степь — финты вида

S>
S>var MyMeth(int i)
S>{
S>    return i <= 0?
S>        null :
S>        new
S>        {
S>            I = i,
S>            Next = MyMeth(i-1)
S>        };
S>}
S>

И тут тоже

S>>Потому уверен что обсуждается структурная эквивалентность только анонимных типов.

S>Тогда совсем неинтересно. Первая же проблема: как инстанс анонимного типа передать через параметр?
Не вижу проблемы. Объявляем параметр примерно так
void Foo({ A:string, B: int} value);
и передаем. Все что имеет совместимый тип должно передаваться без вопросов. Неочевидным будет лишь value.GetType().

S>>А это не про анонимные типы.

S>Про них. Потому что у нас всё вышеперечисленное может работать с анонимными типами. И ждать косяков от
S>
S>var x = new { A = 123 };
S>dynamic y = x;
S>WriteLine(y.A);
S>

Это ведь уже как-то работает с анонимными типами?
S> или от
S>
S>var x = new { A = 123 };
S>x.GetType().Assembly;
S>

Тут неоднозначность раньше возникает. Уже GetType() вернет неизвестно что.
S>только потому, что у нас подгрузилась другая сборка с структурно эквивалентным типом и при разрешении CallSite полезли неочевидности, не хочется ну вот совсем.
Верно, не хочется.
S>Конечно, есть альтернативный вариант: для всех структурно эквивалентных анонимных типов в рантайме генерится анонимный тип, прописанный в mscorlib, но там тоже есть свои неоднозначности.
S>Ну и VladD2 предложил именно вариант с подменой на первый попавшийся совместимый тип — его и обсуждаем пока.
Можно обсудить и другие варианты. Например, генерацию кода для конвертации совместимых типов вместо их подмены рантаймом.
Re[15]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 23.12.13 13:24
Оценка:
Здравствуйте, samius, Вы писали:

S>Потому уверен что обсуждается структурная эквивалентность только анонимных типов.


Влад, имхо, как раз таки обсуждает
Автор: VladD2
Дата: 22.12.13
именно глобальную эквивалентность.

S>>Там дело не только в атрибутах — придётся искать проблемные места в TypeDescriptor, CustomReflectionContext, сериализаторах и т.д. и т.п.

S>А это не про анонимные типы.

Если есть хитрый тип, то его можно будет передать туда, где используется стандартная компонентная модель (их, кстати, несколько). А значит надо, как минимум, понять что при этом получится.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[17]: C# 6.0
От: Sinix  
Дата: 23.12.13 13:53
Оценка:
Здравствуйте, samius, Вы писали:

S>>Причём к "выкинуть нафиг" рано или поздно сводится почти всё, начиная с "добавить ещё одно поле к результату". Ну и зачем связываться?

S>не понял. Для того что бы добавить еще одно или 10 полей к результату, выкидывать не надо.
Надо. Т.к. сборки пользователей завязаны на старую сигнатуру и их никто перекомпилировать после каждого сервис-пака не будет.

S>А связываемся мы с этим затем, что бы мы могли делать объявления методов, совместимые с анонимными типами. Linq-у это здорово поможет.

Не поможет. Добавляем всего-то
var a = 
  from y in x.Y
  from z in y.Z
  let a = new { A = y, B = z }
  group new { y, S = a } by a into g
  select SomeFunc(g.Key, g.First());

и
void Foo({ A:string, B: int} value);

превращается в "мамадорогая, зачем я с этим связался " Смысл анонимных типов — в отсутствии необходимости описывать тип. Как только мы описали тип — всё, можно его вытащить в явное описание и не страдать фигнёй.

Ну, или оставить как есть и проверять сигнатуры вручную при каждом мерже исправлений
Альтернативщину вида "пишем Foo(var a) — компилятор разрулит" лучше оставить языкам с рантайм-верификацией типов, для шарпа это всё-таки изврат

S>Я не вижу здесь причин для того что бы делать типы вложенными.

Проектирование мейнстримного ЯП должно осуществляться чуть по другим критериям Просто потому, что если дырка есть — её обязательно используют и она так и останется, чисто из соображений совместимости.

Навскидку — ApplicationException/SystemException, Delegate/MulticastDelegate, AppDomainSetup.ShadowCopyFiles = "True" (угу, строковая константа), ковариантные массивы, IEnumerator в виде структуры, delegate.BeginInvoke() и прочее-прочее так и остались с нами спустя 11 лет после выхода первого фреймворка (ёшкин кот, как время летит!).

Так что лучше не создавать себе проблем, чем потом геройски с ними бороться.


S>Объявляем параметр примерно так

S>void Foo({ A:string, B: int} value);
Оно будет работать только для совсем примитивных вариантов. Чуть посложнее — и мы завязнем в сверке сигнатур после каждой правки.

S>и передаем. Все что имеет совместимый тип должно передаваться без вопросов. Неочевидным будет лишь value.GetType().

А у мейнстрим-языка нет права на "всё ок, но тут неочевидным будет". Берём шанс получить ошибку (довольно высокий, учитывая средний уровень по палате), умножаем на количество пользователей — получаем дофигаллион потраченного времени и хороший плевок себе в карму как разработчику.


S>>>А это не про анонимные типы.

S>>Про них. Потому что у нас всё вышеперечисленное может работать с анонимными типами. И ждать косяков от
S>>
S>>var x = new { A = 123 };
S>>dynamic y = x;
S>>WriteLine(y.A);
S>>

S>Это ведь уже как-то работает с анонимными типами?
Да, но только потому, что у нас нет граблей с изменением CallSite от запуска к запуску. Грубо говоря, метод T<>anon.get_A не должен прыгать из сборки в сборку

S>> или от

var x = new { A = 123 };
x.GetType().Assembly;

S>Тут неоднозначность раньше возникает. Уже GetType() вернет неизвестно что.
Ага. Но пользователю от этого не легче

S>>Ну и VladD2 предложил именно вариант с подменой на первый попавшийся совместимый тип — его и обсуждаем пока.

S>Можно обсудить и другие варианты. Например, генерацию кода для конвертации совместимых типов вместо их подмены рантаймом.
А это уже реальнее. Тогда надо вводить явное приведение с ducktyping, аля
var x = y castas ISomeFeature; // y не реализует ISomeFeature, в x попадает обёртка с ссылкой на y, реализующая ISomeFeature

Минусы конечно будут, например — сложность с возвращением исходной ссылки на y, зная только x.
Как плюс — мы вообще освобождаемся от проблемы "как обозвать анонимный тип чтобы оставить его анонимным". Ну, и не надо трогать рантайм — всё можно сделать силами компилятора.
Re[12]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 24.12.13 01:38
Оценка: 39 (1)
Здравствуйте, Sinix, Вы писали:

S>Проблемы решаются и даже несколькими способами, но каждый из вариантов порождает новые. Для начала, что должен вывести:

S>?

Для начала нужно заметить, что вывод типов на глобальном уровне плохая идея. Она навредит интелисенсу.

Должно быть возможно определять такие типы явно. Нечто вроде:
using LacalNameForRecord = <string Name, int Age>;

public <string Name, int Age> F(<string Name, int Age> param) // через параметры как-то так, но это на практике не нужно
{
  return param;
}

public LacalNameForRecord F() // через параметры как-то так, но это на практике не нужно
{
  return new { Name="A", Age=42 };
}

Синтаксис не так важен. Важно только чтобы он был краток и не конфликтовал с теми местами где возможно объявление типа.

S>Тут какой вариант не выбери — будут свои косяки.


Что-то я их не улавливаю. Можно по подробнее?

S>Кстати, какую подсказку должна показывать студия при наведении на a — "Тип 1", или "Тип 2"?


Такую:

<string Name, int Age>

это структурные типы. Нечего думать о них как о наминативных.

S>Если ничего не путаю, она сводится к динамичесмкому маппингу к заданному интерфейсу, т.е. это не совсем структурная эквивалентность.


Здесь и нужно сделать динамическое отображение типов. Делать поддержку структурной типизации с нуля слишком объемная задача. Предлагаемого мной решения хватит за глаза.

VD>>Проверка структурной эквивалентности типов производится в момент загрузки сборок/типов. Далее для нужд рефлексии и т.п. используем первый попавшийся тип, а остальные позволяет передавать там где ожидаются их структурные эквиваленты.


S>Ага, это один из вариантов. У него три проблемы:

S>1. Сразу идёт лесом сериализация, т.к. типы исходного и десериализованного значений могут отличаться.

Еще раз, по буквам. Совместимость типов обеспечивает рантайм. Если у кого-то вдруг есть другой тип, он все равно должен эквивалентен исходному. Рантайм просто должен подменять ссылки при попытке их получения, или обеспечить эквивалентность путем переопределения виртуальных методов обжекта.

S>2. Замедляется загрузка сборок из-за проверки на эквивалентность типов.


Не стоит придумывать не существующих проблем. Это вопрос качества реализации. Потом тебя вот мало волнует то, что сейчас загрузка классов безбожно тормозит, а какие-то там сравнения токенов тебя вдруг так взволновали.

S>3. Непредсказуемо ломается биндинг и прочие методы, завязанные на рефлексию.


С чего бы это?

S>Например, Attribute.IsDefined() — атрибут-то можно навесить только на один из типов.


Ох, ох, ох... Эквивалентными могут быть только эквивалентные типы. Если у них различаются атрибуты, то выдаем ошибку компиляции дублируем ее исключением при загрузке в рантайме. Для проверки достаточно создать шифровальный хэш с типа и сравнивать их. Если есть разница — в лес.

S> Или завязка на по полное имя типа/его guid. Причём упасть оно может не на тестах, а уже в продакшне, например, из-за изменившейся логики ngen.


Не выдумывай проблем. А то эдак любую пургу можно обосновать.

S>Это будут два разных типа, поскольку они объявлены в разных библиотеках. И то, что они _сейчас_ совпадают вплоть до имён-типов полей не даёт никаких гарантий, что так будет и в будущем.


На то во фреймворк нужно встроить дополнительные проверки. Как я уже говорил выше, достаточно сварганить хэш и сравнивать его. У того же гита никаких проблем при сравнении целых репозиториев.

S>С явным описанием типов у нас может быть только одно место, где мы ломаем совместимость сборок — собственно, само описание типа. С структурной эквивалентностью мы расширяем его до любой публичной сигнатуры, возвращающей анонимный тип. Затраты на тестирование возрастают соответственно.


Расшифруй плиз свои мысли.
За одно подумай почему с сигнатурами функций нет тех же проблем и какая разница между ними и записями. Вот чем отличается изменение:
void Foo(int a, strind b);

на
void Foo(strind b, int a);

от
<int a, strind b> Foo();

на
<strind b? int a>  Foo();

?

Фиг бы даже с тем, что изменение публичного АПИ — это не очень дальновидное занятие. Но в чем же все таки отличие от методов? Я вижу только одно — перестановка именованных членов может вообще не вызвать проблем, так как обращение к ним по именам идет.

S>Такие вещи нестрашны для мелких проектов. Для энтерпрайза, где типовое требование "чтоб работало на произвольной версии и не падало после обновлений" оно не подходит.


Какая-то мантра. Меня интересуют исключительно технические подробности.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[15]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 24.12.13 01:40
Оценка: -1
Здравствуйте, AndrewVK, Вы писали:

AVK>

AVK>Ты, видимо, о чем то о своем, а не про razor.
AVK>...
AVK>Не розлин, а razor.


Да, да. А до этого страница в стиле "да", "нет". Мне, после третьей строки, просто не захотелось на это тратить свое время.

VD>>Что до Разор вс. Т4, то это замена шыла на мыло.


AVK>Если оставить за скобками жутко избыточный синтаксис Т4, то может быть.


Не плохая идея. Тебя же не напрягает жудко избыточный синтаксис шарпа?

AVK>Но если не шашечки а ехать, то разор сильно удобнее.


Это ни шашечки, и не ехать. Это костыли. Ехать на них не выйдет. Так, ковылять потихонечку.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: C# 6.0
От: Sinix  
Дата: 24.12.13 05:21
Оценка:
Здравствуйте, VladD2, Вы писали:


VD>Должно быть возможно определять такие типы явно. Нечто вроде:

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

Для полной красоты потребуется способ прописывать using-и на уровне сборки + генерация в рантайме TypeInfo с пропиской типа в mscorlib и принципиально большинства косяков не будет.

Я зачем-то зациклился на анонимных типах как они есть в текущем шарпе. Вот их, как не крути, использовать неудобно.

Короче говоря, тут я сливаюсь, возражения забираю

S>>С явным описанием типов у нас может быть только одно место, где мы ломаем совместимость сборок — собственно, само описание типа. С структурной эквивалентностью мы расширяем его до любой публичной сигнатуры, возвращающей анонимный тип. Затраты на тестирование возрастают соответственно.

VD>Расшифруй плиз свои мысли.
VD>За одно подумай почему с сигнатурами функций нет тех же проблем и какая разница между ними и записями. Вот чем отличается изменение: ...

Так сравнивать надо не параметры vs анонимные типы, а анонимные типы vs обычные. В обычном варианте добавление/удаление неиспользуемых полей ничего не ломает *(пока у нас тип — не структура, да и то после перекомпиляции зависимых сборок всё будет ок).
С анонимными типами любое изменение публичной сигнатуры приводит к проверке всего зависимого кода. Из-за лёгкости протаскивания анонимных типов через методы эта зависимая область будет очень большой. Одно но: это относилось к синтаксису что предлагали выше по теме — с автоматическим выводом возвращаемого значения, аля
public var X() { return new { A = 1, B = 2 }; }

// ...

public var Y() { return X(); }

Если по-прежнему явно указывать возвращаемый тип — такой проблемы не будет конечно.
Re[10]: C# 6.0
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 24.12.13 06:47
Оценка:
Здравствуйте, VladD2, Вы писали:



VD>В метаданных нужно всего лишь отразить факт того что тип рассматривается как структурно эквивалентный. Это можно сделать даже простым атрибутом.


VD>Вот что должно измениться, так это поведение фремворка. Но тут проблем возникнуть не должно.


Можно Ввести структуры по типу Action<T,T1,R>
struct АнонимнаяСтруктура<T1,T1,T3>
{
   T1 первоеПоле;
   T2 второеполе;
   T3 третьеПоле;
}


А вот в при создании анонимного типа уже для каждого поля прикрутить атрибутами реальное наименование полей.
и солнце б утром не вставало, когда бы не было меня
Re[8]: C# 6.0
От: Sinclair Россия https://github.com/evilguest/
Дата: 24.12.13 07:12
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>А как знать что внутри при вызове метода ?

К моменту вызова метода он уже скомпилирован, и компилятор заменил var на вполне определённый типа.
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[16]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 24.12.13 07:20
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Потому уверен что обсуждается структурная эквивалентность только анонимных типов.


AVK>Влад, имхо, как раз таки обсуждает
Автор: VladD2
Дата: 22.12.13
именно глобальную эквивалентность.

Я не очень внимательно читал предыдущую дискуссию, но именно то сообщение говорит как раз об обратном:

Нужно соглашение по которому фреймворк будет считать типы одинаковыми и позволять передавать один вместо другого.

В метаданных нужно всего лишь отразить факт того что тип рассматривается как структурно эквивалентный. Это можно сделать даже простым атрибутом.


AVK>Если есть хитрый тип, то его можно будет передать туда, где используется стандартная компонентная модель (их, кстати, несколько). А значит надо, как минимум, понять что при этом получится.

Абсолютно согласен. Но я не думаю что у обсуждаемых типов должны быть серьезные отличия от текущих анонимных в этом отношении.
Re[18]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 24.12.13 08:02
Оценка:
Здравствуйте, Sinix, Вы писали:

S>Здравствуйте, samius, Вы писали:


S>>не понял. Для того что бы добавить еще одно или 10 полей к результату, выкидывать не надо.

S>Надо. Т.к. сборки пользователей завязаны на старую сигнатуру и их никто перекомпилировать после каждого сервис-пака не будет.
В этом отношениии выкидывание точно так же приведет к перекомпилированию.

S>>А связываемся мы с этим затем, что бы мы могли делать объявления методов, совместимые с анонимными типами. Linq-у это здорово поможет.

S>Не поможет. Добавляем всего-то
S>
S>var a = 
S>  from y in x.Y
S>  from z in y.Z
S>  let a = new { A = y, B = z }
S>  group new { y, S = a } by a into g
S>  select SomeFunc(g.Key, g.First());
S>

S>и
S>
S>void Foo({ A:string, B: int} value);
S>

S>превращается в "мамадорогая, зачем я с этим связался " Смысл анонимных типов — в отсутствии необходимости описывать тип. Как только мы описали тип — всё, можно его вытащить в явное описание и не страдать фигнёй.
Не вижу тут мамыдорогой
Вот допустим, хочу параметризовать Linq2Sql запрос предикатом, полученным в параметре метода. Как мне поможет явное описание типа? По-моему никак. Тут даже фигней не пострадать. Только впихивать все возможные предикаты в тело метода, где я строю запрос и выбирать предикаты по маркеру/идентификатору. С наличием возможности использовать анонимные типы вовне можно будет передавать Expression с предикатом извне и передавать результат запроса наружу.

S>Ну, или оставить как есть и проверять сигнатуры вручную при каждом мерже исправлений

S>Альтернативщину вида "пишем Foo(var a) — компилятор разрулит" лучше оставить языкам с рантайм-верификацией типов, для шарпа это всё-таки изврат
У F#-а ведь нет рантайм верификации типов?

S>>Я не вижу здесь причин для того что бы делать типы вложенными.

S>Проектирование мейнстримного ЯП должно осуществляться чуть по другим критериям Просто потому, что если дырка есть — её обязательно используют и она так и останется, чисто из соображений совместимости.
А причем тут вложенность?

S>Навскидку — ApplicationException/SystemException, Delegate/MulticastDelegate, AppDomainSetup.ShadowCopyFiles = "True" (угу, строковая константа), ковариантные массивы, IEnumerator в виде структуры, delegate.BeginInvoke() и прочее-прочее так и остались с нами спустя 11 лет после выхода первого фреймворка (ёшкин кот, как время летит!).


S>Так что лучше не создавать себе проблем, чем потом геройски с ними бороться.

Верно. Но я пока даже их не увидел.
Я не предлагаю такие изменения в C# 6.0 и даже 9.0. Я просто для себя пытаюсь понять, почему принципиально нет? Где проблема?

S>>Объявляем параметр примерно так

S>>void Foo({ A:string, B: int} value);
S>Оно будет работать только для совсем примитивных вариантов. Чуть посложнее — и мы завязнем в сверке сигнатур после каждой правки.
Завязнем. Но лучше завязнуть в принципиальной возможности, чем без таковой. Имхо.
В F# есть констрейнты на наличие у дженерик типа свойств. Можно было бы заюзать что-то подобное.

S>>и передаем. Все что имеет совместимый тип должно передаваться без вопросов. Неочевидным будет лишь value.GetType().

S>А у мейнстрим-языка нет права на "всё ок, но тут неочевидным будет". Берём шанс получить ошибку (довольно высокий, учитывая средний уровень по палате), умножаем на количество пользователей — получаем дофигаллион потраченного времени и хороший плевок себе в карму как разработчику.
Мы уже имеем дофигаллион потраченного времени. И продолжаем его тратить. Развитие языка делается именно для того что бы тратить его меньше.
yield-ы и async-и — здоровенный плевок в карму. Но те, кто насобачился ими пользоваться, получили отличный инструмент.

S>>Это ведь уже как-то работает с анонимными типами?

S>Да, но только потому, что у нас нет граблей с изменением CallSite от запуска к запуску. Грубо говоря, метод T<>anon.get_A не должен прыгать из сборки в сборку
Отлично, пусть висит в System.Runtime.CompilerServices.CallSite

S>>Тут неоднозначность раньше возникает. Уже GetType() вернет неизвестно что.

S>Ага. Но пользователю от этого не легче
Если честно, то в голову не приходят даже сценарии использования GetType для анонимных типов (кроме линк провайдеров). Их можно выдумать, но зачем? А линк провайдеру должно быть пофигу, если типы эквивалентны.

S>>Можно обсудить и другие варианты. Например, генерацию кода для конвертации совместимых типов вместо их подмены рантаймом.

S>А это уже реальнее. Тогда надо вводить явное приведение с ducktyping, аля
S>
S>var x = y castas ISomeFeature; // y не реализует ISomeFeature, в x попадает обёртка с ссылкой на y, реализующая ISomeFeature
S>

S>Минусы конечно будут, например — сложность с возвращением исходной ссылки на y, зная только x.
S>Как плюс — мы вообще освобождаемся от проблемы "как обозвать анонимный тип чтобы оставить его анонимным". Ну, и не надо трогать рантайм — всё можно сделать силами компилятора.
Это интересно само по себе. Но я подразумевал всего лишь что-то типа ILMerge под капотом при передаче совместимых анонимных типов. И это тоже можно решить без рантайма.
Re: C# 6.0
От: Аноним  
Дата: 24.12.13 08:07
Оценка: -2
Здравствуйте, Аноним, Вы писали:

Судя по всему, у дизайнеров языка нет цели — они сами не знают, к чему стремятся и что оптимизируют (это можно сказать не только про C#, но и про многие другие языки, это какой-то бич всей области разработки языков). Пока что курс намечается на то, что язык будет все более сложным для изучения и чтения и будет превращаться в концептуально-синтаксическую помойку, что не может не огорчать, так как C# первое время подавал пример того, как надо подходить к разработке новых языков.

Мне что-то кажется, что этот уклон в сторону примешивания фич и синтаксиса из функциональных языков идет от Липперта, а не от Хейлсберга. Возможно, этим двум людям вообще стоило бы разрабатывать два разных языка.
Re[2]: C# 6.0
От: Jack128  
Дата: 24.12.13 08:16
Оценка:
Здравствуйте, Аноним, Вы писали:

А>Мне что-то кажется, что этот уклон в сторону примешивания фич и синтаксиса из функциональных языков идет от Липперта, а не от Хейлсберга. Возможно, этим двум людям вообще стоило бы разрабатывать два разных языка.


Липперт уже год как не работает в MS.
Re[4]: C# 6.0
От: Sinclair Россия https://github.com/evilguest/
Дата: 24.12.13 08:35
Оценка:
Здравствуйте, Ziaw, Вы писали:
Z>Ты имеешь в виду другой конструктор?
Я так понял, что тот же самый:
public class Person(string name) 
{
  if (string.IsNullOrEmpty(name))
    throw new ArgumentException("name", "name must be a non-empty string!");
}
Уйдемте отсюда, Румата! У вас слишком богатые погреба.
Re[11]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 24.12.13 14:30
Оценка: +1
Здравствуйте, Serginio1, Вы писали:

S>Можно Ввести структуры по типу Action<T,T1,R>


Это будет кортеж. Оно и так есть. Весь смысл в именованных полях.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[12]: C# 6.0
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 24.12.13 14:54
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, Serginio1, Вы писали:


S>>Можно Ввести структуры по типу Action<T,T1,R>


VD>Это будет кортеж. Оно и так есть. Весь смысл в именованных полях.

Ну можно сделать перегрузку из кортежа в класс и обратно.
Например есть класс содержащий кортеж и свойства которые обращаются к этому полю.
Тогда приведение типа будет только в копировании ссылки на кортеж
и солнце б утром не вставало, когда бы не было меня
Re[14]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 24.12.13 14:57
Оценка: 38 (2) +1
Здравствуйте, Sinix, Вы писали:

S>Так сравнивать надо не параметры vs анонимные типы, а анонимные типы vs обычные.


Зачем? Это такая же "зациклиность". Ты просто привык так думать. Если взглянуть на это под другим углом, то становится понятным, что список параметров ничем не отличается от возвращаемого значения. у нас есть функция которая определяется двумя записями входящей и исходящей. Можно даже вот такую запись для функциональных типов придумать:
<int x, int y> -> <string name, bool isMale>

вместо идиотских делегатов.

Тоже самое для кортежей:
<int, int> -> <string, bool>

Система типов от этого становится логичной и последовательной. Делегаты, при этом, можно будет выражать через функциональные типы. Они станут номинативным вариантом функционального типа. В прочем про них быстро забудут, так как они были не более чем ошибкой дизайна.

S>С анонимными типами любое изменение публичной сигнатуры приводит к проверке всего зависимого кода.


Все тоже самое при изменении списка параметров любой функции. И это никого не останавливает от использования функций. А ведь (в теории) можно было бы обойтись функциями с одним параметрам и предлагать заводить новые типы для каждого метода.

S>Из-за лёгкости протаскивания анонимных типов через методы эта зависимая область будет очень большой.


1 в 1 как со списком параметров.

S>Одно но: это относилось к синтаксису что предлагали выше по теме — с автоматическим выводом возвращаемого значения, аля

S>
S>public var X() { return new { A = 1, B = 2 }; }
S>public var Y() { return X(); }
S>

S>Если по-прежнему явно указывать возвращаемый тип — такой проблемы не будет конечно.

Ну, какой смысл его рассматирвать? Я сразу сказал, что глобальный вывод типов — это плохое решение для языка который хочет обладать хорошей поддержкой IDE. Это просто другая проблема.

Даже если ты сделаешь глобальный вывод типов, но не сделаешь поддержки анонимных типов вообще, то все равно эта проблема будет тебя преследовать.

Кстати, логично было бы позволять задавать имя и для атомарного возвращаемого значения функций:
<int index> IndexOf(T value);

Это облегчило бы IDE создание хороших имен для переменных принимающих значение функции и сделало бы язык более единообразным.
Естественно, что это должно быть необязательным. Так же как и должно быть возможно забить на мена и сделать вместо записи кортеж.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[13]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 24.12.13 15:00
Оценка:
Здравствуйте, Serginio1, Вы писали:

S>Ну можно сделать перегрузку из кортежа в класс и обратно.

S>Например есть класс содержащий кортеж и свойства которые обращаются к этому полю.
S>Тогда приведение типа будет только в копировании ссылки на кортеж

Это все никому не нужные приседания. С кортежами работу можно организовать без переделки рантайма. Для полноценной поддержки записей (правильных анонимных типов) нужно менять рантайм. Только это изменение сильно проще нежели себе представляют многие.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: C# 6.0
От: Ziaw Россия  
Дата: 24.12.13 15:54
Оценка:
Здравствуйте, Sinclair, Вы писали:

Речь шла о фиче:

А>>//primary constructors —

А>>public class Point(int x, int y) { }

Влад сказал, что это аналог немерловой макры Record.

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


Насколько я понимаю, в primary constructor, логику реализовать не получится. Вот и хотел уточнить, что он имел в виду.
Re[6]: C# 6.0
От: Jack128  
Дата: 24.12.13 16:31
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Насколько я понимаю, в primary constructor, логику реализовать не получится.

ну вот это как раз большой вопрос. ПОтому что в том же F# как раз можно реализовать логику в праймари конструкторе. http://msdn.microsoft.com/en-us/library/dd233192.aspx
Re[7]: C# 6.0
От: Ziaw Россия  
Дата: 24.12.13 19:26
Оценка:
Здравствуйте, Jack128, Вы писали:

Z>>Насколько я понимаю, в primary constructor, логику реализовать не получится.

J>ну вот это как раз большой вопрос. ПОтому что в том же F# как раз можно реализовать логику в праймари конструкторе. http://msdn.microsoft.com/en-us/library/dd233192.aspx

Есть. И не только в F#. Но представленный синтаксис для C# выглядит так, как будто нельзя.
Re: C# 6.0
От: DreamMaker  
Дата: 24.12.13 21:32
Оценка:
a есть хоть какая-то инфа когда его ждать?

фичи вкусные вполне, хоть все больше и "сахарные"
In P=NP we trust.
Re[14]: C# 6.0
От: Serginio1 СССР https://habrahabr.ru/users/serginio1/topics/
Дата: 25.12.13 06:47
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Здравствуйте, Serginio1, Вы писали:


S>>Ну можно сделать перегрузку из кортежа в класс и обратно.

S>>Например есть класс содержащий кортеж и свойства которые обращаются к этому полю.
S>>Тогда приведение типа будет только в копировании ссылки на кортеж

VD>Это все никому не нужные приседания. С кортежами работу можно организовать без переделки рантайма. Для полноценной поддержки записей (правильных анонимных типов) нужно менять рантайм. Только это изменение сильно проще нежели себе представляют многие.


Если Анонимный класс сделать наследником Кортежа,а в метаклассе (Type) будет содержать хэш соединенных строк полей, то и может и рантайм менять не надо. Так при приведении сначала сравнивается базовый класс, а затем Хэш полей и если они совпадают то считаются одинаковыми
и солнце б утром не вставало, когда бы не было меня
Re[16]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 08:59
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Мне, после третьей строки, просто не захотелось на это тратить свое время.


Это все лирика. А факт состоит в том, что ты не читаешь сообщения, на которые отвечаешь.

AVK>>Если оставить за скобками жутко избыточный синтаксис Т4, то может быть.

VD>Не плохая идея. Тебя же не напрягает жудко избыточный синтаксис шарпа?

Напрягает. При том что он не далеко не настолько избыточный, как Т4 с его громоздким хмлем.

AVK>>Но если не шашечки а ехать, то разор сильно удобнее.

VD>Это ни шашечки, и не ехать. Это костыли. Ехать на них не выйдет.

Кому как. Пока, из обсуждаемых здесь технологий, ковыляет совсем не разор.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[19]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 08:59
Оценка:
Здравствуйте, samius, Вы писали:

S>Вот допустим, хочу параметризовать Linq2Sql запрос предикатом, полученным в параметре метода. Как мне поможет явное описание типа? По-моему никак. Тут даже фигней не пострадать. Только впихивать все возможные предикаты в тело метода, где я строю запрос и выбирать предикаты по маркеру/идентификатору. С наличием возможности использовать анонимные типы вовне можно будет передавать Expression с предикатом извне и передавать результат запроса наружу.


Ничего не понял. Сейчас предикаты в where прекрасно передаются без описанного тобой ужаса. И какая связь между типом предиката и возвращаемым результатом?

S>>Ага. Но пользователю от этого не легче

S>Если честно, то в голову не приходят даже сценарии использования GetType для анонимных типов

Да элементарно. Создаем в компоненте свойство или коллекцию с анонимным типом, а потом пытаемся посмотреть что PropertyGrid показывает. Или, как тут уже много раз упоминалось, просто сериализуем. Я уж не говорю про то, что кодогенерация во всяких мапперах и linq2db с типами-нетипами резко усложняется, потому что этот кейс придется обруливать чуть менее чем везде.

S>А линк провайдеру должно быть пофигу, если типы эквивалентны.


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

S>Но я подразумевал всего лишь что-то типа ILMerge под капотом при передаче совместимых анонимных типов. И это тоже можно решить без рантайма.


Продемонстрируй на псевдокоде.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[17]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 08:59
Оценка:
Здравствуйте, samius, Вы писали:

AVK>>Если есть хитрый тип, то его можно будет передать туда, где используется стандартная компонентная модель (их, кстати, несколько). А значит надо, как минимум, понять что при этом получится.

S>Абсолютно согласен. Но я не думаю что у обсуждаемых типов должны быть серьезные отличия от текущих анонимных в этом отношении.

Текущий анонимный — это совершенно честный тип без какой либо химии в рантайме. Но анонимные типы в разных сборках — разные, несовместимые между собой даже при полном совпадении сигнатуры.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[5]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 08:59
Оценка:
Здравствуйте, Sinclair, Вы писали:

S>Я так понял, что тот же самый:

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


Не не не, так нельзя.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[2]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 08:59
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>Мне что-то кажется, что этот уклон в сторону примешивания фич и синтаксиса из функциональных языков идет от Липперта


Липперт уже в МС не работает.

А>а не от Хейлсберга


Ну, все что здесь описано идет таки не от него, хотя он, разумеется, участвует в их разработке и право вето у него тоже имеется. От него идет кое какая другая фича, но ее по ссылке в стартовом сообщении не описали, а я про нее рассказать пока не могу, NDA.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[2]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 09:03
Оценка:
Здравствуйте, DreamMaker, Вы писали:

DM>a есть хоть какая-то инфа когда его ждать?


Определенного ничего нет. Скорее всего выход новой студии будет приурочен к выходу Windows 8.2.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[3]: C# 6.0
От: Аноним  
Дата: 25.12.13 11:41
Оценка:
Здравствуйте, AndrewVK, Вы писали:

А что минус-то поставил. С чем не согласен?
Re[3]: C# 6.0
От: Аноним  
Дата: 25.12.13 12:07
Оценка: +4 -2
Здравствуйте, VladD2, Вы писали:

VD>Так давно бы перешол на Немерл. Мы уже много лет всем этим пользуемся.


Это реально детский сад какой-то с этой агитацией за Nemerle. Как ты себе представляешь "переход на Nemerle" в коммерческом проекте?

C# — один из самых популярных языков программирования, поддерживаемый фирмой Microsoft, с большой накопленной базой кода во всем мире, с большим сообществом профессионалов и большим выбором программистов, Nemerle — экспериментальный язык от непонятно кого в непонятно каком состоянии с непонятно какими перспективами. Он вообще достиг состояния production? Есть некая Nitra от JetBrains, но это же какой-то другой проект, который еще и не закончен.

Потом, с командой C#-программистов что делать, переучивать? А все ли захотят? Всем ли надо будет прерывать профессиональный опыт C#, чтобы в резюме была строчка с N годами Nemerle, который непонятно кому нужен. Что программиста на собеседовании на C# потом спросят: "Так, значит, вы уже N лет не программировали на C#"? Да он и сам начнет подзабывать C#, если будет на Nemerle программировать.

А как искать новых программистов, давать объявление "Требуется программист Nemerle"? Так и предвижу поток кандидатов.

А что делать с базой кода на C#, переписывать кусками, перемешивать с Nemerle? А если потребуется потом этот Nemerle-C# проект поддерживать с субконтракторами или аутсорсерами? Даже если аутсорсер возьмется, цена точно будет выше из-за экзотического языка. Ну и, опять же, что делать потом с этой базой Nemerle-кода, если проект Nemerle завтра сдохнет?

Ну и, наконец, где доказательства, что в реальных больших и длинных коммерческих проектах с обычными программистами Nemerle дает преимущества?
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 25.12.13 12:51
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>А что минус-то поставил. С чем не согласен?


С первым утверждением.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 25.12.13 16:16
Оценка:
Здравствуйте, Аноним, Вы писали:

А>Это реально детский сад какой-то с этой агитацией за Nemerle.


Детский сад — это вот такие вот заявления.

А>Как ты себе представляешь "переход на Nemerle" в коммерческом проекте?


Скачиваешь последнюю версию интеграции и добавляешь новый проект Nemerle в солюшен.

А>C# — один из самых популярных языков программирования, поддерживаемый фирмой Microsoft, с большой накопленной базой кода во всем мире, с большим сообществом профессионалов и большим выбором программистов,


И что? Все это куда-то девается что ли?

Все остается на месте.

А>Nemerle — экспериментальный язык от непонятно кого в непонятно каком состоянии с непонятно какими перспективами. Он вообще достиг состояния production?


Он то давно достиг.

Меня вот такие теоретики как ты прикалывают. Сначала выдал тираду о том что проект экспериментальный, а потом задался вопросом о том в каком состоянии проект.

А>Есть некая Nitra от JetBrains, но это же какой-то другой проект, который еще и не закончен.


Который пишется на этом "экспериментальном" проекте, а почему-то не на C#, хотя все члены команды владеют шарпом в совершенстве.
И другие пишут.

А>Потом, с командой C#-программистов что делать, переучивать? А все ли захотят? Всем ли надо будет прерывать профессиональный опыт C#, чтобы в резюме была строчка с N годами Nemerle, который непонятно кому нужен. Что программиста на собеседовании на C# потом спросят: "Так, значит, вы уже N лет не программировали на C#"? Да он и сам начнет подзабывать C#, если будет на Nemerle программировать.


А>А как искать новых программистов, давать объявление "Требуется программист Nemerle"? Так и предвижу поток кандидатов.


А>А что делать с базой кода на C#, переписывать кусками, перемешивать с Nemerle?


Да что хочешь. Можешь оставить как есть. Шарп и Немерл совместимы как Шарп и Васик (и даже больше). Хочешь библиотеку на одном для другого напиши. А если очень надо, то шарповский код можно напрямую добавлять в немерловые проекты. Немерл уже пару лет умеет компилировать широкий сабсет 4-го шарпа.

А>А если потребуется потом этот Nemerle-C# проект поддерживать с субконтракторами или аутсорсерами?


Значит будешь поддерживать. Или сиди и соси лапу.

А>Даже если аутсорсер возьмется, цена точно будет выше из-за экзотического языка.


Тут все просто. Если ты делашь ставку на быдлокодеров, в простонародье называемых индусами, то этот язык не для тебя. Этот язык для тех кто хочет увеличить свои возможности, свою производительность. Кто не хочет ждать милостей от МС или Оракла, а хочет сам добавлять в язык то что ему нужно.

А>Ну и, опять же, что делать потом с этой базой Nemerle-кода, если проект Nemerle завтра сдохнет?


А если сдохнет Шарп? МС тоже не вечна.

Я как бы от тебя, наверно, мало чем отличаюсь. Но когда мне что-то не понравилось в компиляторе, то пошел и поправил это.
А такие как ты сидят и дестялетиями бубнят себе под но — "А что мы будем делать если проект сдохнет?...". Он не сдохнет пока он нужен хотя бы одному толковому программисту. А это случится только, если появится язык существенно луче и люди перейдут на него.

А>Ну и, наконец, где доказательства, что в реальных больших и длинных коммерческих проектах с обычными программистами Nemerle дает преимущества?


Для тех кому нужны доказательства есть шарпы и еще более убогие явы. Вы можете сидеть и годами ждать когда МС реализует вам оператор ?. А я пошел и сделал его за час работы.

Лично мне доказательства не нужны. Я просто использую его в не маленьком проекте. И делаю это не первый раз. И не я один, надо заметить.

А вы бойтесь дальше. Ждите мифических доказательств.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: C# 6.0
От: Ziaw Россия  
Дата: 25.12.13 16:32
Оценка: +2
Здравствуйте, Аноним, Вы писали:

А>Что программиста на собеседовании на C# потом спросят: "Так, значит, вы уже N лет не программировали на C#"?


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

А>Да он и сам начнет подзабывать C#, если будет на Nemerle программировать.


Не начнет. Но возвращаться будет больно.

Влад прав, применять Немерл имеет смысл для опытных людей, которым не хватает остальных способов борьбы со сложностью. В руках джуниора он будет лишь чуть более привлекателен синтаксически и менее привлекателен без решарпера.

С другой стороны Влад не прав в том, что язык вполне готов к продакшену, тем не менее я его несколько раз там использовал и не жалею об этом. Решения тех задач без немерла стоили бы заметно дороже. Хотя я буду очень рад, когда наконец доведут до ума Найтру и перепишут немерл на ней.
Re[2]: C# 6.0
От: Ziaw Россия  
Дата: 25.12.13 16:48
Оценка:
Здравствуйте, Аноним, Вы писали:

А>Пока что курс намечается на то, что язык будет все более сложным для изучения и чтения и будет превращаться в концептуально-синтаксическую помойку.


Я думаю тебе следует провести эксперимент и пописать сейчас на C# v1.0. После этого должно прийти понимание, в какой стороне находится помойка.

Это если ты уже плотно используешь в работе лямбды, linq, вывод типов. Если еще не используешь, просто проигнорируй мое сообщение.
Re[18]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 26.12.13 07:31
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Абсолютно согласен. Но я не думаю что у обсуждаемых типов должны быть серьезные отличия от текущих анонимных в этом отношении.


AVK>Текущий анонимный — это совершенно честный тип без какой либо химии в рантайме. Но анонимные типы в разных сборках — разные, несовместимые между собой даже при полном совпадении сигнатуры.

Да. Но почему компонентные модели должны ломаться от совместимых типов?
Вполне допускаю что чего-то не знаю.
Re[20]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 26.12.13 07:45
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Вот допустим, хочу параметризовать Linq2Sql запрос предикатом, полученным в параметре метода. Как мне поможет явное описание типа? По-моему никак. Тут даже фигней не пострадать. Только впихивать все возможные предикаты в тело метода, где я строю запрос и выбирать предикаты по маркеру/идентификатору. С наличием возможности использовать анонимные типы вовне можно будет передавать Expression с предикатом извне и передавать результат запроса наружу.


AVK>Ничего не понял. Сейчас предикаты в where прекрасно передаются без описанного тобой ужаса. И какая связь между типом предиката и возвращаемым результатом?

Видимо, неудачно выразился. Представим что где-то внутри сложного запроса мы получили некий анонимный тип.
new { Product = product.Name, Category = category.Name }
Так вот, предикат для этого анонимного типа невозможно передать извне, т.к. он анонимный. А при наличии совместимых типов можно было бы передать такой предикат извне.

S>>Если честно, то в голову не приходят даже сценарии использования GetType для анонимных типов


AVK>Да элементарно. Создаем в компоненте свойство или коллекцию с анонимным типом, а потом пытаемся посмотреть что PropertyGrid показывает. Или, как тут уже много раз упоминалось, просто сериализуем. Я уж не говорю про то, что кодогенерация во всяких мапперах и linq2db с типами-нетипами резко усложняется, потому что этот кейс придется обруливать чуть менее чем везде.

Что не так с PropertyGrid-ом? Анонимные типы вроде не сериализуются. Кодогенерация — да, согласен. Но это в случае с подменой типов.

S>>А линк провайдеру должно быть пофигу, если типы эквивалентны.


AVK>Чтобы линк-провайдеру все было пофигу, IL должен быть у всех типов идентичный. А для этого обязательно корежить рантайм и преизрядно.

согласен

S>>Но я подразумевал всего лишь что-то типа ILMerge под капотом при передаче совместимых анонимных типов. И это тоже можно решить без рантайма.


AVK>Продемонстрируй на псевдокоде.

Вау
Биг пардон, бес попутал. Я думал о совершенно другом. Automapper/Emit mapper etc. Крутилось в голове что там генерируется IL, и почему-то Merge меня не смутил.
Вобщем, вместо подмены типов предлагаю юзать рассмотреть, даже не рассмотреть, а предположить реализацию совместимых типов на Object2Object маппере, который будет вызываться при передаче экземпляра одного анонимного типа в другой со схожей сигнатурой.
Re[3]: C# 6.0
От: Аноним  
Дата: 26.12.13 11:39
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Это если ты уже плотно используешь в работе лямбды, linq, вывод типов. Если еще не используешь, просто проигнорируй мое сообщение.


Я вообще без лямбд и линка код не пишу. Не for-ы же писать? Дело не в этом, а в концептуальной стройности языка и сложности его синтаксиса.

Например, язык C — концептуально чист (тем, что прост как дверь), но программировать на нем мне совершенно не нравится из-за его ограниченности и кучи тупой ручной работы, Хаскель — тоже относительно концептуально чист, но программировать на нем весело и приятно.

Но функционально-императивный кентавр, в которого превращается C#, у меня вызывает сомнения. По-моему, затаскивать в императивный C-подобный язык синтаксический сахар из ML-языков — это уже перебор. Все-таки, автору языка надо сопоставлять преимущества фич языка с растущей сложностью и поддерживать общую концепцию. А то получится невероятно сложный винегрет из всех языков, в котором одно и то же можно будет сделать настолько разным кодом, что нельзя даже будет подумать, что это написано на одном языке.

Все-таки, неплохо бы авторам языков начать смотреть в реальные проблемы программирования, а не делать из языков швейцарские ножи, занимаясь развитием ради развития.

Неплохо бы понимать, что каждая финтифлюшка усложняет язык, повышает порог вхождения и усложняет сопровождение кода. То, что легко писать — не всегда легко читать и изменять.

Последние изменения в C# наталкивают на мысль, что авторы языка несколько забылись. Это ведь очень легко — начать пихать в язык фичи.

Проблема в том, что, похоже, никто даже не пытается определить, какие параметры в языках программирования следует оптимизировать. Я сильно сомневаюсь, что количество фич и объем синтаксического сахара — это те параметры, которые сильно влияют на производительность разработки всего проекта в перспективе.
Re[21]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 27.12.13 11:55
Оценка: +1
Здравствуйте, samius, Вы писали:

S>Видимо, неудачно выразился. Представим что где-то внутри сложного запроса мы получили некий анонимный тип.

S>new { Product = product.Name, Category = category.Name }
S>Так вот, предикат для этого анонимного типа невозможно передать извне, т.к. он анонимный.

Так тут чисто логическая проблема — если тип появляется внутри метода, то, естественно, снаруж о нем никто не знает. Да и вообще странная идея — конструируемый внутри тип возвращается наружу. Обычно все таки именно вызывающий код знает что ему нужно, поэтому операцию проекции, конструирующую анонимный тип, передают снаружи. И в этом случае нет никаких проблем снаружи же передать предикат для этого анонимного типа.

S>Что не так с PropertyGrid-ом?


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

S> Анонимные типы вроде не сериализуются.


Еще раз — анонимный тип сейчас это абсолютно обычный тип, поэтому и проблем с ним нет.

S>Вобщем, вместо подмены типов предлагаю юзать рассмотреть, даже не рассмотреть, а предположить реализацию совместимых типов на Object2Object маппере, который будет вызываться при передаче экземпляра одного анонимного типа в другой со схожей сигнатурой.


В такой схеме свои проблемы возникают — статически далеко не всегда удастся понять, нужно ли меппинг делать или нет. Это как с nullable типами — на первый взгляд рантайму про них знать не нужно, а вот если внимательно посмотреть, то таки под них пришлось рантайм переделывать.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[19]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 27.12.13 12:07
Оценка:
Здравствуйте, samius, Вы писали:

S>Да. Но почему компонентные модели должны ломаться от совместимых типов?


Потому что они про эту совместимость ничего не знают и будут выкидывать TypeCastException.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 27.12.13 12:10
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>Все-таки, неплохо бы авторам языков начать смотреть в реальные проблемы программирования


Именно это они и делают. Но хотелось бы услышать про то, какие ты проблемы считаешь реальными.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[4]: C# 6.0
От: Ziaw Россия  
Дата: 28.12.13 05:26
Оценка: +1
Здравствуйте, Аноним, Вы писали:

А>Но функционально-императивный кентавр, в которого превращается C#, у меня вызывает сомнения. По-моему, затаскивать в императивный C-подобный язык синтаксический сахар из ML-языков — это уже перебор. Все-таки, автору языка надо сопоставлять преимущества фич языка с растущей сложностью и поддерживать общую концепцию. А то получится невероятно сложный винегрет из всех языков, в котором одно и то же можно будет сделать настолько разным кодом, что нельзя даже будет подумать, что это написано на одном языке.


Функционально-императивным кентавром он стал после введения лямбд. Те, кому это не по нраву не должны использовать лямбды, а ты утверждаешь, что к ним не относишься.

Синтаксический сахар из ML протаскивают, чтобы потом не было мучительно больно вводить другой, очень серьезный и нужный принцип. Который называется — "все есть выражение".

А>Все-таки, неплохо бы авторам языков начать смотреть в реальные проблемы программирования, а не делать из языков швейцарские ножи, занимаясь развитием ради развития.


Что за реальные проблемы программирования?
Re[5]: C# 6.0
От: AlexRK  
Дата: 28.12.13 06:48
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Синтаксический сахар из ML протаскивают, чтобы потом не было мучительно больно вводить другой, очень серьезный и нужный принцип. Который называется — "все есть выражение".


Оффтопик, но я лично не очень понимаю, зачем и кому этот принцип нужен. Цикл — выражение? Ну это же тупо. А методы с побочными эффектами делать выражением я бы вообще запретил (понятно, тут речь уже не о C#).
Re[6]: C# 6.0
От: Ziaw Россия  
Дата: 28.12.13 15:22
Оценка: +2
Здравствуйте, AlexRK, Вы писали:

ARK>Оффтопик, но я лично не очень понимаю, зачем и кому этот принцип нужен. Цикл — выражение? Ну это же тупо. А методы с побочными эффектами делать выражением я бы вообще запретил (понятно, тут речь уже не о C#).


Вызов метода с побочными эффектами это уже выражение, как-то живем с этим. Цикл можно рассмотреть, как частный случай выражения, который возвращает void. Это не тупее, чем отказ от разделения на function и procedure.
Re[6]: C# 6.0
От: Ziaw Россия  
Дата: 28.12.13 15:43
Оценка: 12 (1) +1
Здравствуйте, AlexRK, Вы писали:

ARK>Оффтопик, но я лично не очень понимаю, зачем и кому этот принцип нужен.


Этот принцип формирует правильную культуру ветвления алгоритма. Сводит к минимуму использование мутабельных переменных, а иммутабельные переменные это и не переменные вовсе, это символьное обозначение какого-то значения, которое мы получили где-то ранее. В таком коде сделать ошибку сложнее, а заметить проще, это большой плюс.

сравни:
var a = 5;

if (condition)
  a = 10;

// и

var a = if (condition) 5 else 10;


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

На закуску попробуй переписать код на языке, в котором using не является выражением:
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);

Типы не важны, можешь взять любые, с которыми код скомпилируется.
Re[22]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 28.12.13 18:07
Оценка: +1
Здравствуйте, AndrewVK, Вы писали:

AVK>Так тут чисто логическая проблема — если тип появляется внутри метода, то, естественно, снаруж о нем никто не знает.

Это естественно сейчас, и мы обсуждаем как раз способ уйти от такой естественности.
AVK>Да и вообще странная идея — конструируемый внутри тип возвращается наружу.
Я здесь ничего странного не вижу. В любом случае конструируемый тип возвращается наружу. Только сейчас его надо описать снаружи, а обсуждаем мы случай, когда этого можно будет не делать.
AVK>Обычно все таки именно вызывающий код знает что ему нужно, поэтому операцию проекции, конструирующую анонимный тип, передают снаружи. И в этом случае нет никаких проблем снаружи же передать предикат для этого анонимного типа.
Мы сейчас не можем снаружи передать операцию проекции, конструирующую анонимный тип. Потому что тип анонимный. И предикат передать тоже не можем.

S>>Что не так с PropertyGrid-ом?


AVK>Он использует ту самую компонентную модель, которая сейчас ничего не знает про хитрую структурную эквивалентность некоторых типов.

Влад предлагает делать подмену типов в рантайме. Потому PropertyGrid-ы не узнают об этих хитростях.

S>> Анонимные типы вроде не сериализуются.


AVK>Еще раз — анонимный тип сейчас это абсолютно обычный тип, поэтому и проблем с ним нет.

Да, и структурно-эквивалентный тип будет абсолютно обычным типом. Поэтому я и не пойму, о каких проблемах мы говорим.

S>>Вобщем, вместо подмены типов предлагаю юзать рассмотреть, даже не рассмотреть, а предположить реализацию совместимых типов на Object2Object маппере, который будет вызываться при передаче экземпляра одного анонимного типа в другой со схожей сигнатурой.


AVK>В такой схеме свои проблемы возникают — статически далеко не всегда удастся понять, нужно ли меппинг делать или нет. Это как с nullable типами — на первый взгляд рантайму про них знать не нужно, а вот если внимательно посмотреть, то таки под них пришлось рантайм переделывать.

Можно пример, когда не удастся понять, нужно ли меппинг делать?
Re[20]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 28.12.13 18:11
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Да. Но почему компонентные модели должны ломаться от совместимых типов?


AVK>Потому что они про эту совместимость ничего не знают и будут выкидывать TypeCastException.

Мы обсуждаем два варианта. 1) где совместимые типы будут подменены в рантайме, тогда мы получим лишь один тип для всех совместимых. 2) где совместимые типы маппятся. Где тут приведения типов?
Re[7]: C# 6.0
От: AlexRK  
Дата: 28.12.13 18:54
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Вызов метода с побочными эффектами это уже выражение, как-то живем с этим.


Ну, это ничего не значит. Много с чем живем, например с нуллабельными по умолчанию ссылками, что есть бред.

Z>Цикл можно рассмотреть, как частный случай выражения, который возвращает void. Это не тупее, чем отказ от разделения на function и procedure.


На мой взгляд, разделение концептуально гораздо чище.
Re[7]: C# 6.0
От: AlexRK  
Дата: 28.12.13 19:00
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Этот принцип формирует правильную культуру ветвления алгоритма. Сводит к минимуму использование мутабельных переменных


Не понимаю, каким образом.

Z>В таком коде сделать ошибку сложнее, а заметить проще, это большой плюс.


По-моему, ровно наоборот. В выражении пропустить побочный эффект гораздо проще, чем когда он один гордо красуется на одной строке.

Z>Второй вариант о смысле кода говорит больше, чем первый. Во втором варианте сразу видно, что а может иметь два значения в зависимости от условия. В первом варианте мы только строим гипотезы в процессе чтения.


Это-то понятно, и наличие в языке if/switch в виде выражений исключительно полезно. А вот нафига циклы и процедуры в виде выражений?

Z>На закуску попробуй переписать код на языке, в котором using не является выражением:

Z>
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>

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


Re[23]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 28.12.13 19:43
Оценка:
Здравствуйте, samius, Вы писали:

AVK>>Так тут чисто логическая проблема — если тип появляется внутри метода, то, естественно, снаруж о нем никто не знает.

S>Это естественно сейчас, и мы обсуждаем как раз способ уйти от такой естественности.

Я не очень понимаю, зачем от нее уходить. Вот зачем нужна инлайн декларация типа — понятно. А вот так чтобы именно сконструированный по использованию тип в контракты тащить — вот тут смысл для меня теряется.

S>Мы сейчас не можем снаружи передать операцию проекции, конструирующую анонимный тип


Ты уверен? Ты то ли как то опять странно объясняешь, то ли почему то считаешь что в обычном линке использовать анонимные типы в предикатах нельзя.

AVK>>Он использует ту самую компонентную модель, которая сейчас ничего не знает про хитрую структурную эквивалентность некоторых типов.

S>Влад предлагает делать подмену типов в рантайме. Потому PropertyGrid-ы не узнают об этих хитростях.

Именно поэтому — узнают.

AVK>>Еще раз — анонимный тип сейчас это абсолютно обычный тип, поэтому и проблем с ним нет.

S>Да, и структурно-эквивалентный тип будет абсолютно обычным типом.

Не будет. Если бы он был обычным, не понадобилось бы менять рантайм.

S>Можно пример, когда не удастся понять, нужно ли меппинг делать?


Можно
var x = new <A int, B string>(1, "1");
var y = Foo(); // вызывает "new <A int, B string>(1, "1")" из другой сборки
Console.WriteLine(x == y); // компилятор знает типы, вызывается меппер, выводится True
Console.WriteLine((object)x == (object)y); // компилятор не знает типы, сравниваются ссылки, выводится False
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[21]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 28.12.13 19:54
Оценка:
Здравствуйте, samius, Вы писали:

S>Мы обсуждаем два варианта. 1) где совместимые типы будут подменены в рантайме, тогда мы получим лишь один тип для всех совместимых. 2) где совместимые типы маппятся. Где тут приведения типов?


С подменой в рантайме понятно, вопрос только в том как эта подмена будет проводится. В от как ты будешь мапперы вставлять без изменения компонетных моделей, учитывая что у них в качестчве значений сплошь object используется мне непонятно.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[5]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 28.12.13 19:54
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Функционально-императивным кентавром он стал после введения лямбд.


И что такого принципиально нового добавили лямбды по сравнению с анонимными методами?
Функционально-императивным шарп делают не столько его фичи, сколько то как его используют, коммьюнити в том числе. Поэтому очень странно претензии предъявлять МС. Если бы с функциональщиной были какие то серьезные проблемы, она бы просто не использовалась бы особо.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[8]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 29.12.13 02:39
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Это-то понятно, и наличие в языке if/switch в виде выражений исключительно полезно. А вот нафига циклы и процедуры в виде выражений?


Для концептуальной стройности. Да и на практике это может быть полезно. Вот код на Nemerle:
def result =
  namedBlok : {
    foreach (x when Test(x) in xs)
      namedBlok(x); // нечто типа локального return-а.
    -1 // значение по умолчанию
  };
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[24]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 29.12.13 02:44
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Можно

AVK>
AVK>var x = new <A int, B string>(1, "1");
AVK>var y = Foo(); // вызывает "new <A int, B string>(1, "1")" из другой сборки
AVK>Console.WriteLine(x == y); // компилятор знает типы, вызывается меппер, выводится True
AVK>Console.WriteLine((object)x == (object)y); // компилятор не знает типы, сравниваются ссылки, выводится False
AVK>


"(object)x == (object)y" — это проверка равенства ссылок. Она всегда false должна дать. Вот если "x.Equals(y)", то другое дело.

Но тут как проблем не будет. Equals и GetHeshCode для структурно эквивалентных типов нужно подменять, а так же реализовывать у них IEquatable<T>.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 29.12.13 02:47
Оценка: +1
Здравствуйте, AndrewVK, Вы писали:

AVK>И что такого принципиально нового добавили лямбды по сравнению с анонимными методами?


Это странный вопрос для человека который видит огромную разницу между Разером и Т4.

Синтаксис. Писать в функциональном стиле с анонимными методами очень некрасиво. Код получается громоздким.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[8]: C# 6.0
От: Ziaw Россия  
Дата: 29.12.13 12:18
Оценка:
Здравствуйте, AlexRK, Вы писали:

Z>>Этот принцип формирует правильную культуру ветвления алгоритма. Сводит к минимуму использование мутабельных переменных


ARK>Не понимаю, каким образом.


Я приводил пример с if, там мы вынуждены вводить мутабельную переменную, хотя алгоритм этого не требует.

ARK>По-моему, ровно наоборот. В выражении пропустить побочный эффект гораздо проще, чем когда он один гордо красуется на одной строке.


Выражение не обязано быть на одной строке.

ARK>Это-то понятно, и наличие в языке if/switch в виде выражений исключительно полезно. А вот нафига циклы и процедуры в виде выражений?


void это обычная абстракция. Она позволяет не плодить сущности. При разделении на функции и процедуры нам нужны разные механизмы для их передачи в другие функции/процедуры и работы с ними.

Z>>На закуску попробуй переписать код на языке, в котором using не является выражением:

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


ARK> :xz

Вот и я хз, как ты умудряешься кастить массив анонимных типов к MyType.
Re[6]: C# 6.0
От: Ziaw Россия  
Дата: 29.12.13 14:55
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>И что такого принципиально нового добавили лямбды по сравнению с анонимными методами?


Сахар, после которого их использование стало массовой практикой.

AVK>Функционально-императивным шарп делают не столько его фичи, сколько то как его используют, коммьюнити в том числе. Поэтому очень странно претензии предъявлять МС. Если бы с функциональщиной были какие то серьезные проблемы, она бы просто не использовалась бы особо.


Я тут с тобой полностью согласен и никаких претензий МС не предъявляю. Тебе показалось.
Re: C# 6.0
От: Albeoris  
Дата: 29.12.13 15:18
Оценка:
Здравствуйте, Аноним, Вы писали:

// Неплохо.
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) { }
"Хаос всегда побеждает порядок, поскольку лучше организован." (с) Терри Пратчетт
Re[9]: C# 6.0
От: AlexRK  
Дата: 29.12.13 15:58
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Я приводил пример с if, там мы вынуждены вводить мутабельную переменную, хотя алгоритм этого не требует.


Пример с if не является признаком подхода "все есть выражение", он может быть повторен на любом мейнстримовом языке.

Z>Выражение не обязано быть на одной строке.


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

Z>void это обычная абстракция. Она позволяет не плодить сущности. При разделении на функции и процедуры нам нужны разные механизмы для их передачи в другие функции/процедуры и работы с ними.


Согласен. Но вот преимущества такого подхода спорные, ИМХО.

Z>>>На закуску попробуй переписать код на языке, в котором using не является выражением:

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


ARK>> :xz

Z>Вот и я хз, как ты умудряешься кастить массив анонимных типов к MyType.

using MyType = object. Ага?
Кстати, а что там у нас в сигнатуре CallMethodWithArgument(x) в качестве x? Вот такой же тип надо подставить вместо MyType.
Re[10]: C# 6.0
От: rameel https://github.com/rsdn/CodeJam
Дата: 29.12.13 17:00
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>using MyType = object. Ага?

ARK>Кстати, а что там у нас в сигнатуре CallMethodWithArgument(x) в качестве x? Вот такой же тип надо подставить вместо MyType.

Не получится, ибо анонимный тип умеет работать с таким кодом:
private void CallMethodWithArgument<T>(T argument) {
}
... << RSDN@Home 1.2.0 alpha 5 rev. 71>>
Re[11]: C# 6.0
От: AlexRK  
Дата: 29.12.13 17:36
Оценка:
Здравствуйте, rameel, Вы писали:

R>Не получится, ибо анонимный тип умеет работать с таким кодом:

R>
R>private void CallMethodWithArgument<T>(T argument) {
R>}
R>


Пардон, а что с аргументом можно внутри сделать, кроме как вызвать ToString?
В таком случае анонимный тип присваиваем в переменную типа object, эффект будет ровно такой же.
Re[10]: C# 6.0
От: Ziaw Россия  
Дата: 29.12.13 17:37
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Пример с if не является признаком подхода "все есть выражение", он может быть повторен на любом мейнстримовом языке.


Ну да, if в виде выражения уже есть во многих языках. Почему нужно две конструкции вместо одной и нет аналогов для switch, using, try/catch?

ARK>Я в этом месте говорю как раз про запрет выражений с побочными эффектами — вот это действительно сделало бы проще поиск некоторых типов ошибок.


Я не понимаю, что такое запрет выражений с побочными эффектами. О чем ты сейчас говоришь?

ARK>А вот как способствует подход "все есть выражение" тому, что "в таком коде сделать ошибку сложнее, а заметить проще" — это я пока не понял.


Потому, что не захотел.

ARK>Согласен. Но вот преимущества такого подхода спорные, ИМХО.


ИМХО надо как-то раскрывать. А то получается, что на все мои аргументы ты возражаешь "мне кажется, что все не так".

ARK>using MyType = object. Ага?


Ты сам понимаешь, почему это полная ерунда.

ARK>Кстати, а что там у нас в сигнатуре CallMethodWithArgument(x) в качестве x? Вот такой же тип надо подставить вместо MyType.


Там может быть дженерик тип, вместо вызова метода может быть foreach по результату. Как сейчас передать анонимный тип за пределы using/switch/try-catch и далее полноценно с ним работать? Это невозможно в общем случае. Да и работа с любым другим типом выглядит уродливо, для гарантии инициализации переменной нужны подсказки компилятора, а в случае выражения мы точно ее инициализируем и точно сделаем это один единственный раз (только тут еще нужна поддержка иммутабельных переменных).
Re[12]: C# 6.0
От: Ziaw Россия  
Дата: 29.12.13 17:40
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Пардон, а что с аргументом можно внутри сделать, кроме как вызвать ToString?


Много чего. Но я предлагаю отстать от метода. Вместо него может быть любой код, который использует x, обсуждение этого метода уводит разговор в никуда.
Re[11]: C# 6.0
От: AlexRK  
Дата: 29.12.13 18:06
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Ну да, if в виде выражения уже есть во многих языках. Почему нужно две конструкции вместо одной и нет аналогов для switch, using, try/catch?


Для if и switch естественны две формы — в виде выражения и статемента. Для остальных я вижу только statement-форму. В принципе, foreach может быть выражением, если у него вместо тела будет предикат типа "all", "any", "max", "min" и т.п. Это грамотный подход. А "выражение, возвращающее ничто" это какая-то хрень. Конструкции using, try в виде выражений все же не представляю.

Z>Я не понимаю, что такое запрет выражений с побочными эффектами. О чем ты сейчас говоришь?


Это я гипотетически говорю. Что хорошо бы функции с побочными эффектами запрещать использовать в выражениях вообще. Только в виде стейтментов. Понятно, что это не о C#.

Z>ИМХО надо как-то раскрывать. А то получается, что на все мои аргументы ты возражаешь "мне кажется, что все не так".


Про легкость обнаружения ошибок я аргументов не увидел.
Про поддержку анонимных типов — см. ниже.

ARK>>Кстати, а что там у нас в сигнатуре CallMethodWithArgument(x) в качестве x? Вот такой же тип надо подставить вместо MyType.

Z>Там может быть дженерик тип

В смысле с двумя (или более) констрейнтами? Ну это кривизна C#, что он не позволяет объявить переменную типа intersection type. Я бы скорее это ввел в язык, чем "все есть выражение".

Z>Как сейчас передать анонимный тип за пределы using/switch/try-catch и далее полноценно с ним работать? Это невозможно в общем случае. Да и работа с любым другим типом выглядит уродливо, для гарантии инициализации переменной нужны подсказки компилятора, а в случае выражения мы точно ее инициализируем и точно сделаем это один единственный раз (только тут еще нужна поддержка иммутабельных переменных).


Может это и не проблема вовсе? Раз уж речь идет о гипотетическом расширении языка, то можно дать возможность объявлять переменные как "var" без инициализации (кстати, непонятно, почему этого не сделали).
Re[24]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 18:12
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Это естественно сейчас, и мы обсуждаем как раз способ уйти от такой естественности.


AVK>Я не очень понимаю, зачем от нее уходить. Вот зачем нужна инлайн декларация типа — понятно. А вот так чтобы именно сконструированный по использованию тип в контракты тащить — вот тут смысл для меня теряется.

Смысл в том что этот тип объявить проще, чем обычный.
В принципе такая проблема снимается если можно будет делать так:
class MyClass = <A int, B string>;
и использовать его вместо анонимного внутри метода, строящего Linq запрос, возможно с сохранением синтаксиса.
Но пока описать "настоящий" класс с его конструкторами, Equals/ToString/GetHashCode/==/!= в 10 раз сложнее, чем ввести анонимный.

S>>Мы сейчас не можем снаружи передать операцию проекции, конструирующую анонимный тип


AVK>Ты уверен? Ты то ли как то опять странно объясняешь, то ли почему то считаешь что в обычном линке использовать анонимные типы в предикатах нельзя.

Нет, я уверен что в линке использовать анонимные типы в предикатах и проекциях можно, но только если эти предикаты и проекции построены внутри того же метода, где строится линк запрос. Извне передать эти предикаты и проеции нельзя, потому как они используют анонимный тип, который мы не можем указать в сигнатуре.

AVK>>>Он использует ту самую компонентную модель, которая сейчас ничего не знает про хитрую структурную эквивалентность некоторых типов.

S>>Влад предлагает делать подмену типов в рантайме. Потому PropertyGrid-ы не узнают об этих хитростях.

AVK>Именно поэтому — узнают.

Именно поэтому в ратнайме будут экземпляры лишь одного типа и PropertyGrid-ы не увидят экземпляры совместимых типов.

AVK>>>Еще раз — анонимный тип сейчас это абсолютно обычный тип, поэтому и проблем с ним нет.

S>>Да, и структурно-эквивалентный тип будет абсолютно обычным типом.

AVK>Не будет. Если бы он был обычным, не понадобилось бы менять рантайм.

Рантайм меняется лишь для того что бы исключить появление экземпляров других типов. В остальном оставшийся тип будет абсолютно обычным.

S>>Можно пример, когда не удастся понять, нужно ли меппинг делать?


AVK>Можно

AVK>
AVK>Console.WriteLine(x == y); // компилятор знает типы, вызывается меппер, выводится True
AVK>Console.WriteLine((object)x == (object)y); // компилятор не знает типы, сравниваются ссылки, выводится False
AVK>

Тип TwoDPoint из этого гайдлайна с перекрытым оператором == будет вести себя точно так же. Это нормально.
Re[22]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 18:14
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Мы обсуждаем два варианта. 1) где совместимые типы будут подменены в рантайме, тогда мы получим лишь один тип для всех совместимых. 2) где совместимые типы маппятся. Где тут приведения типов?


AVK>С подменой в рантайме понятно, вопрос только в том как эта подмена будет проводится.

У меня нет ответа
AVK>В от как ты будешь мапперы вставлять без изменения компонетных моделей, учитывая что у них в качестчве значений сплошь object используется мне непонятно.
А мне непонятно, зачем юзать маппер для преобразования к object.
Re[12]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 18:21
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Здравствуйте, Ziaw, Вы писали:


Z>>Ну да, if в виде выражения уже есть во многих языках. Почему нужно две конструкции вместо одной и нет аналогов для switch, using, try/catch?


ARK>Для if и switch естественны две формы — в виде выражения и статемента. Для остальных я вижу только statement-форму. В принципе, foreach может быть выражением, если у него вместо тела будет предикат типа "all", "any", "max", "min" и т.п. Это грамотный подход. А "выражение, возвращающее ничто" это какая-то хрень. Конструкции using, try в виде выражений все же не представляю.

Можно использовать выражения, которые возвращают какую-то хрень (см F# Unit type) вместо ничто.
Re[13]: C# 6.0
От: AlexRK  
Дата: 29.12.13 18:37
Оценка:
Здравствуйте, samius, Вы писали:

S>Можно использовать выражения, которые возвращают какую-то хрень (см F# Unit type) вместо ничто.


Это по сути то же самое.

Если уж делать "все есть выражение", то надо во все функции с побочными эффектами передавать "миры" и возвращать их назад.
Re[14]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 18:54
Оценка: +1
Здравствуйте, AlexRK, Вы писали:

ARK>Здравствуйте, samius, Вы писали:


S>>Можно использовать выражения, которые возвращают какую-то хрень (см F# Unit type) вместо ничто.


ARK>Это по сути то же самое.

Нет, это лучше, т.к. не требует разделения на функции, возвращающие что-то, и функции,возвращающие void.

ARK>Если уж делать "все есть выражение", то надо во все функции с побочными эффектами передавать "миры" и возвращать их назад.

Как это поможет, если функция с побочным эффектом не принимает мир, а та что принимает — не имеет побочного эффекта, т.к. принимает мир и возвращает новый?
Re[15]: C# 6.0
От: AlexRK  
Дата: 29.12.13 19:04
Оценка:
Здравствуйте, samius, Вы писали:

S>Нет, это лучше, т.к. не требует разделения на функции, возвращающие что-то, и функции,возвращающие void.


Я считаю, что разделение должно быть, т.к. по факту оно есть.

S>Как это поможет, если функция с побочным эффектом не принимает мир, а та что принимает — не имеет побочного эффекта, т.к. принимает мир и возвращает новый?


Все верно. С использованием "миров" функций с побочными эффектами не будет и поэтому можно применить подход "все есть выражение".
Имею глубокое убеждение, что в выражении не должно быть побочных эффектов.
Re[16]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 19:20
Оценка: +2
Здравствуйте, AlexRK, Вы писали:

ARK>Здравствуйте, samius, Вы писали:


S>>Нет, это лучше, т.к. не требует разделения на функции, возвращающие что-то, и функции,возвращающие void.


ARK>Я считаю, что разделение должно быть, т.к. по факту оно есть.

Оно есть, но оно мешает. Заставляет по дважды описывать функции для Func и Action, для Task<T> и Task и т.п.

ARK>Все верно. С использованием "миров" функций с побочными эффектами не будет и поэтому можно применить подход "все есть выражение".

ARK>Имею глубокое убеждение, что в выражении не должно быть побочных эффектов.
Это во власти разработчика. Отобрать такую возможность практически нереально. Но можно подумать о том, что бы помечать особым образом чистые функции/выражения.
Re[25]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 19:49
Оценка: 7 (1)
Здравствуйте, samius, Вы писали:

S>В принципе такая проблема снимается если можно будет делать так:

S>class MyClass = <A int, B string>;

Это уже совсем иное, чем предлагаемые тут анонимные и структурно эквивалентные типы. Это просто сахар, с ним никаких проблем нет.

S>Но пока описать "настоящий" класс с его конструкторами, Equals/ToString/GetHashCode/==/!= в 10 раз сложнее, чем ввести анонимный.


Ну, видишь, с конструкторами вопрос уже почти решенный.

S>но только если эти предикаты и проекции построены внутри того же метода, где строится линк запрос.


Естественно. И это логично. Во всех остальных ситуациях (ну разве что за исключением нескольких приватных методов одного класса) такой тип становится частью контракта, соответственно выводить его из использования, как в случае анонимных типов это прекрасный способ прострелить себе ногу.

S> Извне передать эти предикаты и проеции нельзя


Можно извне передать проекцию в анонимный тип и предикат для этого анонимного типа.

S>, потому как они используют анонимный тип, который мы не можем указать в сигнатуре.


Указывать его не обязательно, если компилятор сможет вывести.

AVK>>Именно поэтому — узнают.

S>Именно поэтому в ратнайме будут экземпляры лишь одного типа и PropertyGrid-ы не увидят экземпляры совместимых типов.

А в метаданных чего будет?

AVK>>Не будет. Если бы он был обычным, не понадобилось бы менять рантайм.

S>Рантайм меняется лишь для того что бы исключить появление экземпляров других типов.

А как исключить появление разных метаданных для одного типа в разных сборках? Или таки вводим на уровне метаданных новую сущность?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[7]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 19:49
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Это странный вопрос для человека который видит огромную разницу между Разером и Т4.


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

VD>Синтаксис. Писать в функциональном стиле с анонимными методами очень некрасиво. Код получается громоздким.


Код получается громоздким прежде всего не из-за анонимных типов, а из-за отсутствия вывода типов.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[7]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 19:49
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Я тут с тобой полностью согласен и никаких претензий МС не предъявляю. Тебе показалось.


Мне не показалось, эта реплика для Анонима в основном предназначалась.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[12]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 19:49
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Пардон, а что с аргументом можно внутри сделать, кроме как вызвать ToString?


В данном случае более корректной была бы такая сигнатура:
void CallMethodWithArgument<T>(T[] argument)

А с такой сигнатурой уже кой чего можно сделать — кол-во посчитать, склонировать и т.п.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[11]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 19:49
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Я не понимаю, что такое запрет выражений с побочными эффектами. О чем ты сейчас говоришь?


Скорее всего о какой то разновидности state constraints. Вот только в этом случае наличие возможности избежать лишней изменяемой переменной становится еще важнее.

Z>ИМХО надо как-то раскрывать. А то получается, что на все мои аргументы ты возражаешь "мне кажется, что все не так".


Я думаю это, скорее всего, означает "слишком непривычно".
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[12]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 19:49
Оценка: +1
Здравствуйте, AlexRK, Вы писали:

ARK>В принципе, foreach может быть выражением, если у него вместо тела будет предикат типа "all", "any", "max", "min" и т.п. Это грамотный подход.


Вот foreach как раз таки выражением можно и не делать.

ARK> А "выражение, возвращающее ничто" это какая-то хрень. Конструкции using, try в виде выражений все же не представляю.


Вроде уже показали пример. Можно еще проще:
var x = src.Count(i => try { CanThrowException(i) } catch { defaultValue });
var y = src.Sum(i => using(var rc = GetDisposableResource()) rc.Foo(i));
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[12]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 29.12.13 19:55
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Здравствуйте, Ziaw, Вы писали:


Z>>Ну да, if в виде выражения уже есть во многих языках. Почему нужно две конструкции вместо одной и нет аналогов для switch, using, try/catch?


ARK>Для if и switch естественны две формы — в виде выражения и статемента. Для остальных я вижу только statement-форму. В принципе, foreach может быть выражением, если у него вместо тела будет предикат типа "all", "any", "max", "min" и т.п. Это грамотный подход. А "выражение, возвращающее ничто" это какая-то хрень. Конструкции using, try в виде выражений все же не представляю.


Это потому что не та траву язык

using, try и т.д. не обязаны возвращать void, а могут вернуть последнее выражение.
Точно также как и функция, последнее выражение является и значением функции.

Скажем вот так
 def x = using(a = A()) { 1 };


Вот применение try-catch
Автор: VladD2
Дата: 18.04.11
.

Z>>Я не понимаю, что такое запрет выражений с побочными эффектами. О чем ты сейчас говоришь?
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[26]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 21:07
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>class MyClass = <A int, B string>;


AVK>Это уже совсем иное, чем предлагаемые тут анонимные и структурно эквивалентные типы. Это просто сахар, с ним никаких проблем нет.

Согласен. А можем мы в пределах хотя бы сборки считать MyClass и <A int, B string> синонимами? А в сборках, ссылающихся на сборку, где объявлен MyClass, при наличии соответствующей using директивы?

S>>Но пока описать "настоящий" класс с его конструкторами, Equals/ToString/GetHashCode/==/!= в 10 раз сложнее, чем ввести анонимный.


AVK>Ну, видишь, с конструкторами вопрос уже почти решенный.

Все остальное от анонимного типа вполне бы устроило. В том числе риадонли свойства.

S>>но только если эти предикаты и проекции построены внутри того же метода, где строится линк запрос.


AVK>Естественно. И это логично. Во всех остальных ситуациях (ну разве что за исключением нескольких приватных методов одного класса) такой тип становится частью контракта, соответственно выводить его из использования, как в случае анонимных типов это прекрасный способ прострелить себе ногу.

Верно. Если будет короткий способ объявить такой тип, то это поможет. Кстати, в F# тип record коротко объявляется и при создании экземпляра указывать имя не нужно, компилятор выводит тип сам.

S>> Извне передать эти предикаты и проеции нельзя


AVK>Можно извне передать проекцию в анонимный тип и предикат для этого анонимного типа.

Это интересно. Linq2Sql скушает запрос с такой проекцией?
Беда тут в том, что как только мы в запросе воспользуемся этой проекцией, мы получим тип T, чьи свойства мы не знаем. Разобрать его уже не выйдет, если мы не передадим проекции T->XYZ для каждого свойства тоже извне.

S>>, потому как они используют анонимный тип, который мы не можем указать в сигнатуре.


AVK>Указывать его не обязательно, если компилятор сможет вывести.

Если передать вместе с проекцией, то сможет.

AVK>>>Именно поэтому — узнают.

S>>Именно поэтому в ратнайме будут экземпляры лишь одного типа и PropertyGrid-ы не увидят экземпляры совместимых типов.

AVK>А в метаданных чего будет?

В метаданных не будет ничего такого, чего нет у анонимного типа. Конечно, если мы не разрешим вешать атрибуты при объявлении
class MyClass = <[MyAttribute]A:int, ...>

AVK>>>Не будет. Если бы он был обычным, не понадобилось бы менять рантайм.

S>>Рантайм меняется лишь для того что бы исключить появление экземпляров других типов.

AVK>А как исключить появление разных метаданных для одного типа в разных сборках? Или таки вводим на уровне метаданных новую сущность?

Вот, если честно, то к подмене типов в рантайме я немного охладел. И к маппингу тоже.

Теперь мысль крутится следующая: сделать рекорды как в F#, но генерацию типа сделать в точности как сейчас у анонимных типов. Отличие лишь в том, что у него будет цивилизованное имя.
Если при использовании анонимного типа в видимости оказывается запись с соответствующими свойствами, то компилятор вместо анонимного типа использует тип записи. Иначе — генерит анонимный тип.
Использованием считать
а) то как объявляются анонимные типы сейчас, т.е. new { A = 5, B = "10" }
б) объявления вроде <A:int, B: string> (в прямой видимости объявления class MyClass = <A:int, B: string> считать их синонимами).
Re[12]: C# 6.0
От: Ziaw Россия  
Дата: 29.12.13 21:18
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Для if и switch естественны две формы — в виде выражения и статемента. Для остальных я вижу только statement-форму.


И снова "мне кажется, что все не так". Обоснуй. Выражение от стейтмента сейчас отличается тем, что statement возвращает void, а большинство statements должно возвращать результат последнего выражения.

ARK>В принципе, foreach может быть выражением, если у него вместо тела будет предикат типа "all", "any", "max", "min" и т.п. Это грамотный подход.


Как раз этот подход вполне заменяется экстеншен методами для IEnumarable. foreach должен возвращать void (либо быть аналогом Select, но это не очень хороший вариант).

ARK>А "выражение, возвращающее ничто" это какая-то хрень.


Просто ты не хочешь это принимать. Потому команда C# и делает лишь маленький шажок. Вот ты попользуешься и начнешь сам хотеть побольше выражений.

ARK>Конструкции using, try в виде выражений все же не представляю.


Чего их представлять-то, уже привели все примеры.

ARK>Это я гипотетически говорю. Что хорошо бы функции с побочными эффектами запрещать использовать в выражениях вообще. Только в виде стейтментов. Понятно, что это не о C#.


Тут очень сложный вопрос, например db.Table1.Count() это функция с побочными эффектами?

ARK>Про легкость обнаружения ошибок я аргументов не увидел.


Код читабельнее. Алгоритм понимается быстрее. Иммутабельные переменные не позволяют пропустить место, где переменная "незаметно" меняется.

ARK>Может это и не проблема вовсе? Раз уж речь идет о гипотетическом расширении языка, то можно дать возможность объявлять переменные как "var" без инициализации (кстати, непонятно, почему этого не сделали).


Можно конечно, только зачем? Мы решим эту локальную проблему ценой снижения читабельности кода.
Re[25]: C# 6.0
От: Ziaw Россия  
Дата: 29.12.13 21:20
Оценка:
Здравствуйте, samius, Вы писали:

S>В принципе такая проблема снимается если можно будет делать так:

S>class MyClass = <A int, B string>;

Так это и сделали. Праймари конструктор же.
Re[26]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 21:25
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Здравствуйте, samius, Вы писали:


S>>В принципе такая проблема снимается если можно будет делать так:

S>>class MyClass = <A int, B string>;

Z>Так это и сделали. Праймари конструктор же.

Само по себе это хорошо, но будет ли это совместимо с анонимными типами?
Re[27]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 21:55
Оценка:
Здравствуйте, samius, Вы писали:

S>Согласен. А можем мы в пределах хотя бы сборки считать MyClass и <A int, B string> синонимами? А в сборках, ссылающихся на сборку, где объявлен MyClass, при наличии соответствующей using директивы?


Слишком кучеряво, имхо.

AVK>>Можно извне передать проекцию в анонимный тип и предикат для этого анонимного типа.

S>Это интересно. Linq2Sql скушает запрос с такой проекцией?

Это основной сценарий применения анонимных типов в линке.

S>Беда тут в том, что как только мы в запросе воспользуемся этой проекцией, мы получим тип T, чьи свойства мы не знаем.


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

AVK>>А в метаданных чего будет?

S>В метаданных не будет ничего такого, чего нет у анонимного типа.

Так анонимные типы в разных сборках разные, поэтому там такой проблемы не стоит.

S> Конечно, если мы не разрешим вешать атрибуты при объявлении

S>class MyClass = <[MyAttribute]A:int, ...>

При чем тут атрибуты? Ты вытаскиваешь свой хитрый тип в контракты, значит он должен присутствовать в метаданных. Если ничего не делать, то одинаковые в рантайме типы в метаданных будут разными.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[26]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 21:57
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>Так это и сделали. Праймари конструктор же.


Свойства все равно ручками надо декларировать, хоть и по упрощенной схеме.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[27]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 29.12.13 21:57
Оценка:
Здравствуйте, samius, Вы писали:

S>Само по себе это хорошо, но будет ли это совместимо с анонимными типами?


В каком смысле совместимо? Если ты нормальный тип задекларировал анонимныей уже не нужен.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[8]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 29.12.13 22:50
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Между ними, мягко говоря, разницы побольше, чем между лямбдами и анонимными методами.


Э... я даже затрудняюсь квалифицировать данное утверждение. Его кроме как для флэйму и сказать то нельзя.
delegate(Dictionry<int, string> d, int value) { return d[value]; }

sv.
(d, value) => d[value]

мало различимы? Ты это серьезно?

VD>>Синтаксис. Писать в функциональном стиле с анонимными методами очень некрасиво. Код получается громоздким.


AVK>Код получается громоздким прежде всего не из-за анонимных типов, а из-за отсутствия вывода типов.


Дык он часть синтаксических расширений введенных для реализации лямбд.

В прочем, все эти delegate и return сами по себе убивают читабельность чуть менее чем полностью.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[28]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 29.12.13 23:56
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Согласен. А можем мы в пределах хотя бы сборки считать MyClass и <A int, B string> синонимами? А в сборках, ссылающихся на сборку, где объявлен MyClass, при наличии соответствующей using директивы?


AVK>Слишком кучеряво, имхо.

Что я должен на это ответить? Что не слишком, имхо?

AVK>>>Можно извне передать проекцию в анонимный тип и предикат для этого анонимного типа.

S>>Это интересно. Linq2Sql скушает запрос с такой проекцией?

AVK>Это основной сценарий применения анонимных типов в линке.


S>>Беда тут в том, что как только мы в запросе воспользуемся этой проекцией, мы получим тип T, чьи свойства мы не знаем.


AVK>Опять я перестаю тебя понимать. Там где мы анонимный тип конструируем, в том методе все его свойства мы знаем. А в других методах работать с типом, который выводится из использования в чужом коде — довольно странная идея.

Ну вот, мы передали в метод, где конструируем Linq запрос, проекцию, строящую анонимный тип. Это значит что метод, конструирующий Linq запрос уже не может пользоваться свойствами анонимного типа. Ибо это странно, хоть и основной сценарий применения анонимных типов в линке.

AVK>>>А в метаданных чего будет?


AVK>При чем тут атрибуты? Ты вытаскиваешь свой хитрый тип в контракты, значит он должен присутствовать в метаданных. Если ничего не делать, то одинаковые в рантайме типы в метаданных будут разными.

да, проблема с этим есть. Но я уже написал что подмена типов не кажется мне отличной идеей.
Re[28]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 00:03
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Само по себе это хорошо, но будет ли это совместимо с анонимными типами?


AVK>В каком смысле совместимо? Если ты нормальный тип задекларировал анонимныей уже не нужен.

В смысле смогу ли я создавать экземпляры черех new {A = 5, B = "10"}.
Уже понял что нет.
Я думал что primary constructors — это короткий способ объявить тип со свойствами, как анонимный по использованию. Оказалось что это короткий способ объявить тип с конструктором но без свойств. Т.е. F# records даже не на горизонте.
Re[13]: C# 6.0
От: AlexRK  
Дата: 30.12.13 07:30
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Вот foreach как раз таки выражением можно и не делать.


В свете наличия LINQ — возможно. Я просто показал вариант, который, на мой взгляд, логичен для "foreach в виде выражения".

AVK>Вроде уже показали пример. Можно еще проще:

AVK>
AVK>var x = src.Count(i => try { CanThrowException(i) } catch { defaultValue });
AVK>var y = src.Sum(i => using(var rc = GetDisposableResource()) rc.Foo(i));
AVK>


Ну понятно. Это спотыкается о мое неприятие побочных эффектов в выражениях, но это только мое личное мнение и оно не имеет отношения к C#. Раз язык такое позволяет, то ввести можно. Про возврат значений циклами while/do вопрос по прежнему открыт.
Re[13]: C# 6.0
От: AlexRK  
Дата: 30.12.13 07:49
Оценка:
Здравствуйте, Ziaw, Вы писали:

Z>И снова "мне кажется, что все не так". Обоснуй. Выражение от стейтмента сейчас отличается тем, что statement возвращает void, а большинство statements должно возвращать результат последнего выражения.


Ну, если плюнуть на побочные эффекты в выражениях (что я считаю, однако, очень плохим тоном), то можно try/using тоже сделать в форме выражения. Для циклов не знаю, зачем нужно. Разве что для того, чтобы использовать их внутри этих try/using?

Z>Как раз этот подход вполне заменяется экстеншен методами для IEnumarable.


if/switch тоже заменяются методами. Да и все остальное тоже можно заменить методами.

Z>foreach должен возвращать void (либо быть аналогом Select, но это не очень хороший вариант).


Я свою позицию по этому вопросу уже изложил.

Z>Просто ты не хочешь это принимать. Потому команда C# и делает лишь маленький шажок. Вот ты попользуешься и начнешь сам хотеть побольше выражений.


Не думаю.

Z>Тут очень сложный вопрос, например db.Table1.Count() это функция с побочными эффектами?


Да. По моему мнению (с которым, конечно, согласятся не все), она должна быть в виде процедуры: db.Table1.GetCount(out count)

Z>Код читабельнее. Алгоритм понимается быстрее. Иммутабельные переменные не позволяют пропустить место, где переменная "незаметно" меняется.


Это все вкусовщина и имхо. Я вот не понимаю, почему код должен становиться читабельнее и алгоритм пониматься быстрее. Я считаю, что неконтролируемые побочные эффекты ухудшают понимание алгоритма и скрывают потенциальные ошибки (а подход "все есть выражение" этому сильно способствует).

К примеру, вот тут (слегка измененный пример)
  var y = src.Any(i => using(var rc = GetDisposableResource()) rc.Foo(i));

при нахождении первого true остальные элементы перебираться не будут и не будут вызваны методы Foo, которые должны выполнить какой-то ввод-вывод.

Вот с измеряемыми показателями согласиться могу, например наподобие того, о чем говорил samius — что вместо двух функций для Func и Action будет одна.

Иммутабельные переменные вообще ортогональны данному подходу, их можно с успехом применять и во всех других случаях (на всякий пожарный уточняю, что иммутабельная переменная не обязана быть иниициализированной в точке объявления).

Z>Можно конечно, только зачем? Мы решим эту локальную проблему ценой снижения читабельности кода.


Опять вкусовщина без обоснования.
Re[29]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 10:50
Оценка:
Здравствуйте, samius, Вы писали:

S>Что я должен на это ответить? Что не слишком, имхо?


Да ничего не должен. Я просто свое мнение высказываю.

AVK>>Опять я перестаю тебя понимать. Там где мы анонимный тип конструируем, в том методе все его свойства мы знаем. А в других методах работать с типом, который выводится из использования в чужом коде — довольно странная идея.

S>Ну вот, мы передали в метод, где конструируем Linq запрос, проекцию, строящую анонимный тип. Это значит что метод, конструирующий Linq запрос уже не может пользоваться свойствами анонимного типа.

Он не может это делать логически, потому что на момент его написания ничего не известно об этом типе. А чтобы стало известно, надо тип явно описать в параметрах метода. А, знеачит, он оказывается в контрактах. Вот и получается, что, вне зависимости от реальных возможностей анонимных типов, их использование таким манером — крайне сомнительная практика.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[14]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 10:50
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>В свете наличия LINQ — возможно.


В любом свете. У Липперта был пост в блоге, где он объяснял, почему в стандатной библиотеке нет метода Foreach. Почти все что там написано касается и возврата значения оператором цикла.

AVK>>Вроде уже показали пример. Можно еще проще:

AVK>>
AVK>>var x = src.Count(i => try { CanThrowException(i) } catch { defaultValue });
AVK>>var y = src.Sum(i => using(var rc = GetDisposableResource()) rc.Foo(i));
AVK>>


ARK>Ну понятно. Это спотыкается о мое неприятие побочных эффектов в выражениях


В этих выражениях, в общем случае, нет побочных эффектов.

ARK>Про возврат значений циклами while/do вопрос по прежнему открыт.


Все что я писал про foreach касается всех циклов.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[14]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 10:50
Оценка:
Здравствуйте, AlexRK, Вы писали:

Z>>Тут очень сложный вопрос, например db.Table1.Count() это функция с побочными эффектами?

ARK>Да. По моему мнению (с которым, конечно, согласятся не все)

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

Z>>Код читабельнее. Алгоритм понимается быстрее. Иммутабельные переменные не позволяют пропустить место, где переменная "незаметно" меняется.

ARK>Это все вкусовщина и имхо.

Нет. Это тоже наблюдаемый факт — иммутабельный код читается легче и приводит к меньшему количеству ошибок.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[30]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 11:03
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


AVK>Он не может это делать логически, потому что на момент его написания ничего не известно об этом типе. А чтобы стало известно, надо тип явно описать в параметрах метода. А, знеачит, он оказывается в контрактах. Вот и получается, что, вне зависимости от реальных возможностей анонимных типов, их использование таким манером — крайне сомнительная практика.

Правильно, но только потому что они анонимные. Если анонимные типы приравнять к записям, то сомнительность практики станет сомнительна, ведь тип можно будет указывать в параметрах метода.
Re[31]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 11:08
Оценка:
Здравствуйте, samius, Вы писали:

S>Если анонимные типы приравнять к записям, то сомнительность практики станет сомнительна


Их недостаточно просто приравнять к записям. Ключевая особенность анонимных типов — вывод типа по использованию. И именно поэтому и возникают логические проблемы.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[15]: C# 6.0
От: AlexRK  
Дата: 30.12.13 11:08
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>В любом свете. У Липперта был пост в блоге, где он объяснял, почему в стандатной библиотеке нет метода Foreach. Почти все что там написано касается и возврата значения оператором цикла.


Это?
http://blogs.msdn.com/b/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx

Ну так этот его пост полностью подтверждает мою точку зрения. Что циклы в виде выражений не нужны.

Однако я бы добавил, что особый подвид foreach имеет право на жизнь в виде выражения, если будет иметь агрегатную функцию вместо тела. Это полностью согласуется с позицией Липперта.

AVK>В этих выражениях, в общем случае, нет побочных эффектов.


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

AVK>Все что я писал про foreach касается всех циклов.


Просто для foreach можно представить что-то разумное, а для do/while только возврат Void.
Re[15]: C# 6.0
От: AlexRK  
Дата: 30.12.13 11:12
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Это не вопрос твоего мнения, это наблюдаемый факт — Count это чистая функция.


Если речь о стандартном DataTable, оторванном от базы, то естественно, что Count — чистая функция.

Но я так понял по вопросу Ziaw, что он имеет в виду некую "connected" модель, когда Count обращается напрямую к базе, и два последовательных вызова могут дать разные результаты. Вот в таком случае я бы сделал Count процедурой.

AVK>Нет. Это тоже наблюдаемый факт — иммутабельный код читается легче и приводит к меньшему количеству ошибок.


Я говорю не про иммутабельный код, а про подход "все есть выражение". Это вещи, никак не связанные друг с другом.
Против кода с иммутабельными переменными я ничего не имею.
Re[32]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 11:27
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Если анонимные типы приравнять к записям, то сомнительность практики станет сомнительна


AVK>Их недостаточно просто приравнять к записям. Ключевая особенность анонимных типов — вывод типа по использованию. И именно поэтому и возникают логические проблемы.

Хорошо, ключевая особенность анонимных типов порождает проблемы. Какие проблемы порождает предложение слегка их разанонимизировать? Что мешает по использованию вывести тип объявленной ранее записи?
Re[33]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 11:40
Оценка:
Здравствуйте, samius, Вы писали:

S>Хорошо, ключевая особенность анонимных типов порождает проблемы. Какие проблемы порождает предложение слегка их разанонимизировать?


Я уже устал повторять одно и тоже — использование в контрактах выводимых по использованию типов это порождает.

S> Что мешает по использованию вывести тип объявленной ранее записи?


Зачем? Если у нас уже есть глобально доступный тип, то проще и короче сослаться на него.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[16]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 11:40
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Ну так этот его пост полностью подтверждает мою точку зрения. Что циклы в виде выражений не нужны.


Ты тоже не читаешь ответы собеседников? Я тебе уже несколько раз написал тоже самое.

ARK>Однако я бы добавил, что особый подвид foreach имеет право на жизнь в виде выражения, если будет иметь агрегатную функцию вместо тела.


А зачем он нужен?

AVK>>В этих выражениях, в общем случае, нет побочных эффектов.

ARK>Как раз в общем случае есть, мы не знаем, что скрывается за Foo, и следует предположить худшее. C# побочные эффекты никак не контролирует.

Это другой вопрос. Главное — сами операторы никаких побочных эффектов не содержат и нет никаких препятствий сделать их возвращающими значение.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[16]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 11:40
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Но я так понял по вопросу Ziaw, что он имеет в виду некую "connected" модель, когда Count обращается напрямую к базе, и два последовательных вызова могут дать разные результаты. Вот в таком случае я бы сделал Count процедурой.


Что ты бы сделал мы уже поняли. Но это противоречит основополагающим принципам дизайна — менять контракт только потому что поменялись где то очень глубоко внутри детали реализации — это просто фантастическая жесть. А если учесть, что реализация зависит не от метода Count, а от linq-провайдера, который вообще может динамически вычисляться, то все становится еще фантастичнее.

AVK>>Нет. Это тоже наблюдаемый факт — иммутабельный код читается легче и приводит к меньшему количеству ошибок.

ARK>Я говорю не про иммутабельный код, а про подход "все есть выражение". Это вещи, никак не связанные друг с другом.

Это вещи сильно связанные друг с другом. Примеры тебе уже приводили.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[17]: C# 6.0
От: AlexRK  
Дата: 30.12.13 12:15
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Ты тоже не читаешь ответы собеседников? Я тебе уже несколько раз написал тоже самое.


Как раз-таки я читаю ответы, а вы — нет.

Я с самого начала написал:

Цикл — выражение? Ну это же тупо.

В принципе, foreach может быть выражением, если у него вместо тела будет предикат типа "all", "any", "max", "min" и т.п. Это грамотный подход. А "выражение, возвращающее ничто" это какая-то хрень.


На что вы дали не вполне уместные ответы:

Вот foreach как раз таки выражением можно и не делать.

Все что я писал про foreach касается всех циклов.


AVK>А зачем он нужен?


Для удобства. Затем же, зачем query comprehension.

AVK>Это другой вопрос. Главное — сами операторы никаких побочных эффектов не содержат и нет никаких препятствий сделать их возвращающими значение.


Просто эти операторы в некоторых случаях способствуют появлению ошибок, связанных с побочными эффектами (пример я приводил выше).
Re[17]: C# 6.0
От: AlexRK  
Дата: 30.12.13 12:22
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Но это противоречит основополагающим принципам дизайна — менять контракт только потому что поменялись где то очень глубоко внутри детали реализации — это просто фантастическая жесть.


А где они, границы контракта? Почему нет претензий к Count, ведь он возвращает Int32, а вдруг в глубине реализации появилось нечто, возвращающее Int64?
Как обычно — баланс между надежностью и гибкостью. Четкое разделение на чистые/нечистые функции увеличивает предсказуемость, но снижает гибкость.

AVK>А если учесть, что реализация зависит не от метода Count, а от linq-провайдера, который вообще может динамически вычисляться, то все становится еще фантастичнее.


Ну нагородить можно много чего. В том числе дойти и до динамической типизации. Вопрос, где остановиться.

AVK>Это вещи сильно связанные друг с другом. Примеры тебе уже приводили.


Я видел примеры и нахожу их неубедительными.
Не вижу принципиальной разницы между
var a = using(var res = GetRes()) { res.Foo() };

и
var a;
using(var res = GetRes())
{
  a = res.Foo();
}
Re[18]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 30.12.13 12:47
Оценка:
Здравствуйте, AlexRK, Вы писали:


ARK>Я видел примеры и нахожу их неубедительными.

  Скрытый текст
ARK>Не вижу принципиальной разницы между
ARK>
ARK>var a = using(var res = GetRes()) { res.Foo() };
ARK>

ARK>и
ARK>
ARK>var a;
ARK>using(var res = GetRes())
ARK>{
ARK>  a = res.Foo();
ARK>}
ARK>


Разница будет если вместо 'var' будет что-то в стиле 'readonly var' a.k.a 'let', 'def', 'val' и т.п.
Т.е. переменная гарантированно не будет никогда изменяться больше.
В этом случае мы видим одно и единственное место где происходит инициализация.
А обычный 'var' означает, что дальше запросто может быть код вида "a = null;" .
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[34]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 12:53
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Хорошо, ключевая особенность анонимных типов порождает проблемы. Какие проблемы порождает предложение слегка их разанонимизировать?


AVK>Я уже устал повторять одно и тоже — использование в контрактах выводимых по использованию типов это порождает.

А я устал повторять что предлагаю использовать в контрактах записи. Но для этого они хотя бы должны быть.

S>> Что мешает по использованию вывести тип объявленной ранее записи?


AVK>Зачем? Если у нас уже есть глобально доступный тип, то проще и короче сослаться на него.

любой глобально доступный тип может оказаться провайдеру не по силам, т.к. он может иметь нетривиальные геттеры/конструкторы. Нужен именно аналог анонимного типа с именем, т.е. запись.
Re[19]: C# 6.0
От: AlexRK  
Дата: 30.12.13 12:55
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Разница будет если вместо 'var' будет что-то в стиле 'readonly var' a.k.a 'let', 'def', 'val' и т.п.

_NN>Т.е. переменная гарантированно не будет никогда изменяться больше.
_NN>В этом случае мы видим одно и единственное место где происходит инициализация.
_NN>А обычный 'var' означает, что дальше запросто может быть код вида "a = null;" .

Абсолютно никакой разницы. В случае def/let будет то же самое. А если человек попробует после "def a" написать "a = null;" — ошибка компиляции.
Re[20]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 30.12.13 12:59
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Абсолютно никакой разницы. В случае def/let будет то же самое. А если человек попробует после "def a" написать "a = null;" — ошибка компиляции.

Ну так вот подтверждение что есть разница.
var дает возможность менять переменную потом несколько раз, а инициализация сразу через def/let не дает.

Так можно
var a;
using(var res = GetRes())
{
  a = res.Foo();
}

a = null; // :maniac:


А так будет нельзя
def a = using(res = GetRes()) res.Foo();
a = null; // Ошибка компиляции
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[21]: C# 6.0
От: AlexRK  
Дата: 30.12.13 13:10
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Ну так вот подтверждение что есть разница.

_NN>var дает возможность менять переменную потом несколько раз, а инициализация сразу через def/let не дает.

_NN>Так можно

_NN>
_NN>var a;
_NN>using(var res = GetRes())
_NN>{
_NN>  a = res.Foo();
_NN>}

_NN>a = null; // :maniac: 
_NN>


_NN>А так будет нельзя

_NN>
_NN>def a = using(res = GetRes()) res.Foo();
_NN>a = null; // Ошибка компиляции
_NN>


Да БЛИН. Еще раз говорю, никакой разницы не будет.

[c#]
def a;
using(var res = GetRes())
{
a = res.Foo();
}
a = null; // Ошибка компиляции

Короче должно быть ровно одно присваивание в каждом ветвлении.
Re[22]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 30.12.13 13:15
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Да БЛИН. Еще раз говорю, никакой разницы не будет.


ARK>
ARK>def a;
ARK>using(var res = GetRes())
ARK>{
ARK>  a = res.Foo();
ARK>}
ARK>a = null; // Ошибка компиляции


ARK>Короче должно быть ровно одно присваивание в каждом ветвлении.


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

У вашего предложения есть хорошее применение, например в out аргументах.
Однако в данном случае я не вижу никакого смысла разделять определение переменной и инициализацию.

Вы ведь не будете писать:
int b;
b = f();

int a;
if (b) 
 a = 1;
else
 b = 2;


А напишете сразу:
int b = f();
int a = b ? 1 : 2;


Почему с 'using' так не проходит ?
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[23]: C# 6.0
От: AlexRK  
Дата: 30.12.13 13:21
Оценка:
Здравствуйте, _NN_, Вы писали:

_NN>Это конечно похоже, но другое.

_NN>Вы предлагаете вариант, где можно изменить значение только один раз, а я говорю о том что проще когда вообще нет возможности поменять значение.

Нет, я предлагаю вариант, где значение задается только один раз и больше не меняется. Просто определение находится выше первого и единственного присваивания.

_NN>Вы ведь не будете писать:

_NN>Почему с 'using' так не проходит ?

Ну вот это мы как раз и обсуждаем. И циклы тоже.
Re[24]: C# 6.0
От: _NN_ www.nemerleweb.com
Дата: 30.12.13 13:28
Оценка:
Здравствуйте, AlexRK, Вы писали:

ARK>Здравствуйте, _NN_, Вы писали:


_NN>>Это конечно похоже, но другое.

_NN>>Вы предлагаете вариант, где можно изменить значение только один раз, а я говорю о том что проще когда вообще нет возможности поменять значение.

ARK>Нет, я предлагаю вариант, где значение задается только один раз и больше не меняется. Просто определение находится выше первого и единственного присваивания.

Это я понял.
Я не понимаю какой смысл в этом случае ?
Как раз в одном выражение ясно что это и определение и инициализация и не надо искать где и когда устанавливаем значение.

Переменные такого типа нужны, но не в этом случае.


Код может быть запутанным:
A a;

...

if(x)
{
 if(y)
 {
  a = new A();
 }
 else
 {
  a = new A(1);
 }
}

// И в итоге "a" возможно не проинициализирован ..
// Компилятор конечно хороший и нам подскажет.


А если сразу инициализация то этого просто не может произойти даже по ошибке:
def a = 
 if(x)
  if(y)
   new A()
  else
   new A(1);
 // Сразу видим, что не хватает else.
 // Ошибка компиляции , мы не дали значение для переменной !
http://rsdn.nemerleweb.com
http://nemerleweb.com
Re[35]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 13:33
Оценка:
Здравствуйте, samius, Вы писали:

S>А я устал повторять что предлагаю использовать в контрактах записи.


Которые ничего общего с анонимными типами не имеют.

AVK>>Зачем? Если у нас уже есть глобально доступный тип, то проще и короче сослаться на него.

S>любой глобально доступный тип может оказаться провайдеру не по силам, т.к. он может иметь нетривиальные геттеры/конструкторы

Какому провайдеру?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[18]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 13:33
Оценка:
Здравствуйте, AlexRK, Вы писали:

AVK>>Но это противоречит основополагающим принципам дизайна — менять контракт только потому что поменялись где то очень глубоко внутри детали реализации — это просто фантастическая жесть.

ARK>А где они, границы контракта?

В компиляторе.

AVK>>А если учесть, что реализация зависит не от метода Count, а от linq-провайдера, который вообще может динамически вычисляться, то все становится еще фантастичнее.

ARK>Ну нагородить можно много чего. В том числе дойти и до динамической типизации. Вопрос, где остановиться.

Что значит остановится? Есть вполне конкретное твое предложение — менять контракт только из-за особенностей реализации где то глубоко внутри.

ARK>Я видел примеры и нахожу их неубедительными.


Находи, тут разговаривать просто не о чем — как тебе неоднократно писали, обсуждать твои нахождения и предположения не интересно, пока ты не сможешь подкрепить их фактами и аргументами.

ARK>Не вижу принципиальной разницы между

ARK>
ARK>var a = using(var res = GetRes()) { res.Foo() };
ARK>

ARK>и
ARK>
ARK>var a;
ARK>using(var res = GetRes())
ARK>{
ARK>  a = res.Foo();
ARK>}
ARK>


А если это лямбда? А если часть сложного выражения? Тоже не видишь?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[36]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 13:35
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>А я устал повторять что предлагаю использовать в контрактах записи.


AVK>Которые ничего общего с анонимными типами не имеют.

как раз у них все общее, кроме наличия имени.

S>>любой глобально доступный тип может оказаться провайдеру не по силам, т.к. он может иметь нетривиальные геттеры/конструкторы


AVK>Какому провайдеру?

Linq2Sql, например.
Re[37]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 13:47
Оценка:
Здравствуйте, samius, Вы писали:

AVK>>Которые ничего общего с анонимными типами не имеют.

S>как раз у них все общее, кроме наличия имени.

Мне, честно говоря, надоело ходить по кругу:

Ключевая особенность анонимных типов — вывод типа по использованию.


S>>>любой глобально доступный тип может оказаться провайдеру не по силам, т.к. он может иметь нетривиальные геттеры/конструкторы

AVK>>Какому провайдеру?
S>Linq2Sql, например.

Ему не нужно никаких специальных знаний об анонимном типе, он обрабатывает их по тем же правилам, что и любые другие.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[38]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 13:55
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


AVK>>>Которые ничего общего с анонимными типами не имеют.

S>>как раз у них все общее, кроме наличия имени.

AVK>Мне, честно говоря, надоело ходить по кругу:

AVK>

AVK>Ключевая особенность анонимных типов — вывод типа по использованию.

Мне тоже
Одна из особенностей записей (F#) — The compiler infers the type from the labels used (if the labels are sufficiently distinct from those of other record types).

AVK>>>Какому провайдеру?

S>>Linq2Sql, например.

AVK>Ему не нужно никаких специальных знаний об анонимном типе, он обрабатывает их по тем же правилам, что и любые другие.

Естественно. Правила для типов одни, и то что работает для анонимного типа, может не сработать для рукописного типа.
Re[39]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 30.12.13 15:22
Оценка:
Здравствуйте, samius, Вы писали:

S>Одна из особенностей записей (F#)


И что? При чем тут F#?

AVK>>Ему не нужно никаких специальных знаний об анонимном типе, он обрабатывает их по тем же правилам, что и любые другие.

S>Естественно. Правила для типов одни, и то что работает для анонимного типа, может не сработать для рукописного типа.

Например?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[40]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 30.12.13 16:45
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>Одна из особенностей записей (F#)


AVK>И что? При чем тут F#?

Ладно, проехали. Действительно, чего круги нарезать?

AVK>>>Ему не нужно никаких специальных знаний об анонимном типе, он обрабатывает их по тем же правилам, что и любые другие.

S>>Естественно. Правила для типов одни, и то что работает для анонимного типа, может не сработать для рукописного типа.

AVK>Например?

Исключение в конструкторе/аксессоре
Re[14]: C# 6.0
От: Ziaw Россия  
Дата: 30.12.13 20:01
Оценка:
Здравствуйте, AlexRK, Вы писали:

Ты пока не показал ни одного примера, в котором осмысленное использование оператора как выражения создает какие-то проблемы. Прошу учесть этот момент и продолжать дискуссию только с явным пониманием против чего ты борешься и не является ли твое лекарство хуже предполагаемой болезни.

Z>>Как раз этот подход вполне заменяется экстеншен методами для IEnumarable.


ARK>if/switch тоже заменяются методами. Да и все остальное тоже можно заменить методами.


С какой целью? Экстеншен методы для IEnumarable уже есть и прекрасно работают, что даст замена их на тело цикла из агрегата, что бы это не значило? Switch в виде метода это кошмар, который можно предложить только из желания поспорить и отстоять свое, "оригинальное" мнение.

Z>>Тут очень сложный вопрос, например db.Table1.Count() это функция с побочными эффектами?

ARK>Да. По моему мнению (с которым, конечно, согласятся не все), она должна быть в виде процедуры: db.Table1.GetCount(out count)

Все зависит от реализации. Ничто мне не мешает функцию, которая выглядит чистой сделать нечистой, это лишь вопрос культуры кода.

ARK>Это все вкусовщина и имхо. Я вот не понимаю, почему код должен становиться читабельнее и алгоритм пониматься быстрее. Я считаю, что неконтролируемые побочные эффекты ухудшают понимание алгоритма и скрывают потенциальные ошибки (а подход "все есть выражение" этому сильно способствует).


Именно, а использование иммутабельных переменных уменьшает количество требуемых неконтролируемых побочных эффектов. Изменение переменной это само по себе побочный эффект. С другой стороны непонятно, какое отношение побочные эффекты имеют к операторам-выражениям. Больше чем сейчас возможностей для извращенного применения побочных эффектов мы не получаем.

ARK>К примеру, вот тут (слегка измененный пример)

ARK>
ARK>  var y = src.Any(i => using(var rc = GetDisposableResource()) rc.Foo(i));
ARK>

ARK>при нахождении первого true остальные элементы перебираться не будут и не будут вызваны методы Foo, которые должны выполнить какой-то ввод-вывод.

Вероятно это и нужно программисту. Даже если не нужно, это произошло явно не потому, что там using использовали не так, как тебе привычно.

ARK>Иммутабельные переменные вообще ортогональны данному подходу, их можно с успехом применять и во всех других случаях (на всякий пожарный уточняю, что иммутабельная переменная не обязана быть иниициализированной в точке объявления).


Вообще-то обязательно, по крайней мере в тех языках, которые их умеют. Контроль того, что переменная будет гарантировано инициализирована до использования и инициализирована не более одного раза, доставит программисту немало хлопот. Если перестать придумывать воркэраунд для частного примера с using, это легко увидеть (да, я знаю, что это можно ловить автоматом). Ты предлагаешь жуткие костыли, непонятно с какой целью. Эти костыли никак не помогут справиться с пресловутыми побочными эффектами.

Z>>Можно конечно, только зачем? Мы решим эту локальную проблему ценой снижения читабельности кода.

ARK>Опять вкусовщина без обоснования.

Надо обосновать, что разделение места объявления и инициализации переменной снижают читабельность кода? Мне лень искать пруфы, но это азбучная истина.
Re[15]: C# 6.0
От: AlexRK  
Дата: 30.12.13 20:10
Оценка:
Здравствуйте, Ziaw, Вы писали:

Ладно, ОК. Я принял к сведению все точки зрения относительно обсуждаемого вопроса. С чем-то могу согласиться, с чем-то нет. Дальше оффтопить, думаю, нет смысла.
Re[41]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 31.12.13 14:58
Оценка:
Здравствуйте, samius, Вы писали:

AVK>>>>Ему не нужно никаких специальных знаний об анонимном типе, он обрабатывает их по тем же правилам, что и любые другие.

S>>>Естественно. Правила для типов одни, и то что работает для анонимного типа, может не сработать для рукописного типа.
AVK>>Например?
S>Исключение в конструкторе/аксессоре

И в чем хаключается разница в случае linq2sql?
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[27]: C# 6.0
От: Ziaw Россия  
Дата: 01.01.14 19:16
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Свойства все равно ручками надо декларировать, хоть и по упрощенной схеме.


Это они зря, впрочем это должны автоматизировать в следующих версиях, так как это будет слишком часто встречающийся тупой код.
Re[42]: C# 6.0
От: samius Япония http://sams-tricks.blogspot.com
Дата: 02.01.14 00:59
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Здравствуйте, samius, Вы писали:


S>>>>Естественно. Правила для типов одни, и то что работает для анонимного типа, может не сработать для рукописного типа.

AVK>>>Например?
S>>Исключение в конструкторе/аксессоре

AVK>И в чем хаключается разница в случае linq2sql?

Я тут особым образом не выделяю linq2sql. Исключение в конструкторе может нарушить проекцию при работе любого провайдера.
Зря, наверное, сделал акцент на работе провайдеров. Тут больше значимо то, что в описании анонимного типа ошибиться невозможно. У него из коробки все написано корректно. На уровне постулата можно принять то что конструктор не путает поля и не оставляет их непроинициализированными (переданными значениями), плюс заведомо рабочие Equals/GetHashCode/ToString (а могли бы быть еще и ==/!=).
Ручное описание типа, эквивалентного по поведению анонимному — нетривиальная задача. Потому и хочется иметь возможность тривиально описывать такой тип вплоть до совместимости такого явного описания и неявного (по использованию).
Впрочем, совместимость с неявным описанием по использованию — это уже каприз.
Re[43]: C# 6.0
От: AndrewVK Россия http://blogs.rsdn.org/avk
Дата: 02.01.14 14:39
Оценка:
Здравствуйте, samius, Вы писали:

S>На уровне постулата можно принять то что конструктор не путает поля и не оставляет их непроинициализированными (переданными значениями), плюс заведомо рабочие Equals/GetHashCode/ToString (а могли бы быть еще и ==/!=).


Нельзя. Потому что в expression tree нет отдельной ноды для анонимного типа, там обычный вызов обычного конструктора. Нет, можно конечно проанализировать CtorInfo и по какому нибудь хитрому признаку догадаться, что это анонимный тип, но вряд ли делать так — разумная идея.
... << RSDN@Home 1.2.0 alpha 5 rev. 100 on Windows 8 6.2.9200.0>>
AVK Blog
Re[44]: C# 6.0
От: VladD2 Российская Империя www.nemerle.org
Дата: 03.01.14 02:13
Оценка:
Здравствуйте, AndrewVK, Вы писали:

AVK>Нельзя. Потому что в expression tree нет отдельной ноды для анонимного типа, там обычный вызов обычного конструктора. Нет, можно конечно проанализировать CtorInfo и по какому нибудь хитрому признаку догадаться, что это анонимный тип, но вряд ли делать так — разумная идея.


Разумно сделать поддержку анонимных типов в expression tree.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.