//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) { }
А>//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 ???
А>//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' типах ?
Не проще ли кортежи добавить в язык ?
На мой взгляд как раз в публичных методах, которые являются контрактом класса, как раз не нужен вывод типов.
А> А>Имхо, какой то хоть и полезный но хлам.
А>>//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}). Причем тут вообще рантайм?
Здравствуйте, 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}). Причем тут вообще рантайм?
Ну так оно и сейчас так через массив.
Я так понимаю фишка в том, что IEnumerable как раз даст возможность не создавать массив вообще, а скажем , разместить все в стеке.
Иначе снова неясно зачем это.
Массив он и так IEnumerable.
Здравствуйте, _NN_, Вы писали:
_NN>Иначе снова неясно зачем это. _NN>Массив он и так IEnumerable.
Сейчас можно передавать только существующий массив или список аргументов (который преобразуется в массив в месте вызова).
А с params IEnumerable<T> можно будет, кроме того, передавать любые коллекции: List<T>, HashSet<T> и т.д., избегая от ненужного вызова .ToArray() и копирования элементов.
Здравствуйте, _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-параметрами, а не при их декларации.
А когда будет что нибудь более официальное на этот счет? И будут ли какие то более интересные фичи, или это весь список нововведений?
Здравствуйте, nikov, Вы писали:
А>>>//inline declarations for out params — А>>>public void Foo(out var x, out var y) { } _NN>>На мой взгляд как раз в публичных методах, которые являются контрактом класса, как раз не нужен вывод типов. N>Это автор блога что-то намудрил. Предполагается разрешить такой синтаксис при вызовах методов с out-параметрами, а не при их декларации.
Правильно. По мне так дальше нужно идти, не только облегчить работу с out-параметрами, но еще и максимально усложнить работу с туплами. Чтоб даже мысли не возникало их использовать.
А>//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) { }
А>
Здравствуйте, nikov, Вы писали:
N>Сейчас можно передавать только существующий массив или список аргументов (который преобразуется в массив в месте вызова). N>А с params IEnumerable<T> можно будет, кроме того, передавать любые коллекции: List<T>, HashSet<T> и т.д., избегая от ненужного вызова .ToArray() и копирования элементов.
Теперь логично, а то я уже подумал про супер оптимизацию для params
А>>//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#.
Здравствуйте, 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#.
Здравствуйте, _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 из таких.
Здравствуйте, Константин, Вы писали:
К>Проще, но хуже. У out-аргументов кроме типов есть ещё имена. У членов кортежа только типы. К>Поэтому если метод возвращает два значения одного или близких типов, то при использовании двух out аргументов метод можно использовать, не заглядывая в документацию, а только взглянув на прототип.
Практика использования кортежей в языках, где они изначально поддерживаются, показывают одну особенность: их крайне редко их выставляют в публичный интерфейс.
