Еще одно маленькое украшение в синтаксисе Rust

В чём большее удобство?

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

// другой анонимус

как коверкают священный Си...

Многомерные массивы:

int** x;

x = malloc(dimension1_max * sizeof(int*));
for (int i = 0; i < dimension1_max; i++) {
  x[i] = malloc(dimension2_max * sizeof(int));
}

[...]

for (int i = 0; i < dimension1_max; i++) {
  free(x[i]);
}
free(x);

Б - Божественно!

PS: код не мой

Что какие? Скобки? Круглые и квадратные. Интервалы жеж.

x = malloc(dimension2_max * sizeof(int));

Ну кто ж так делает, в С одной аллокацией надо обходиться. Причем в том числе, если этот массив должен быть частью структуры.

Да, теперь припоминаю. Но разве это не из алгебры? Элементарная математика это арифметика скорее.

Но это же элементарно!

[0, 1) - диапазон, от нуля включительно, и не доходя до 1. Как пример.

И самое главное ведь все сразу догадались какой будет шаг :)

Бог с тобой! Это континуум-множество. Был бы шаг, было бы счетным, но это не так)

Не знаю как вам, но для меня вариант БЫЛО гораздо более очевиден, чем СТАНЕТ. Зачем это вообще делать и какие преимущества у такого подхода?

Бог с тобой!

Вот вот. Это же так трудно распознать сарказм...

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

Раст в своем стиле, перл отдыхает.

Ну хоть лучше чем Go.

Удачного дебага.

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

class 2d_array - и всё, далее удобно, хотя не сишечка, но ведь можно a[x][y] оператор? не помню, давно не юзал

Ну так в плюсах есть абстракции, в отличии от. Мы то про сишку.

В чём большее удобство?

Можно менять шаг в процессе итерации.

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

Зачем это вообще делать и какие преимущества у такого подхода?

Консистентность. Вместо двух сущностей «две точки» и «три точки» будет две формы одной сущности «две точки»: с «=» и без ничего. Это не преимущество, это попытка объяснить необходимость ). Тем более, это экспериментальная возможность, которую могут в дальнейшем изменить. Те же "...", получается, запилили и выпилили, не внося в список стабильных и неломаемых фич синтаксиса.

Вместо двух сущностей «две точки» и «три точки» будет две формы одной сущности «две точки»: с «=» и без ничего.

А если я скажу, что раньше было две формы одной сущности «две точки»: с ещё одной точкой и без неё?

Я бы просто использовал range([start], stop[, step]) — чем меньше знаков пунктуации, тем проще читать. Напридумывают всякой херни от которой глаза вытекают..

Я бы просто использовал range([start], stop[, step]) — чем меньше знаков пунктуации, тем проще читать. Напридумывают всякой херни от которой глаза вытекают..

А от дефисов и тире у тебя глаза вытекают?

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

Тоесть ты считаешь что в языке не должно быть сбособа указать диапазон включительно?

Сейчас нет ни первого ни второго варианта. Мне самому второй не очень нравится, но хоть что-то лучше чем ничего.

Я считаю что это не должно быть настолько вырвиглазно, как во втором варианте. for i..10 или for(start, stop, step) - это понятно, логично и привычно. for i..=4 это что-то уже запредельное. Чем больше я узнаю о всяких новых непродакшен языках, тем мне больше кажется что среди разработчиков этих языков программирования идет какое-то негласное соревнование кто придумает более глупый, запутанный и нечитаемый синтаксис. Я не понимаю зачем эти люди это делают, возможно это какое-то скрытое проявление садизма или что-то подобное. Они хотят что бы визитной карточкой rust'а была скорость и безопасность, но в итоге его узнают по совершенно нечитабельному синтаксису. Спроси в случайной компании «что ты думаешь о rust?» и тебе ответят «это тот язык, который невозможно читать». Изучить rust это как изучить ассемблер - сложно, бесполезно и через год забудешь.

Хорошо, вот сейчас добавят читабельный вариант for i...10 и добавят ЭТО for 1..=10. И внезапно окажется что большинство библиотек на гитхабе будут состоять полностью из таких выражений. Потому что круто же использовать таинственные выражения, можно почувствовать себя причастным к узком кругу нетрадици посвященных. А остальным-то как это читать? А никак, проблемы индейцев вождя не волнуют.

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

for i..=4

И ржавчина давно уже в продакшене: ПРУФ

for i..10 или for(start, stop, step) - это понятно

Так погоди, я вот читаю твое сообщение и ты похоже не понял в чем проблема. В расте всегда был и сейчас есть такой синтаксис:

for i in 0..10 {
}

Он считает от 0 до 9 не включая 10. Проблема в том что иногда нужен диапазон «включительно», например ты пишешь такой цикл

for c in 'A'..'Z' {
}

Он тебе даст буквы от A до Y но не даст Z. И что предлагаешь делать в таком случае?

for(start, stop, step) - это понятно, логично и привычно

Только тем, кто пишет на питоне.

А остальным-то как это читать?

Так же как сейчас остальные читают `<<`, `>>`, `->*` и тому подобное. Сначала смотрят в книгу (или на сайт) с описанием языка, а потом читают. Что за тупой вопрос?

Я вряд ли могу что-либо предложить, только замечу (не ради срача) что в Go ты можешь получить именно то, что хочешь https://play.golang.org/p/B5lsrPCzIu

Так как ты написал я тоже умею, но толку то?

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

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

Что-то типа этого? https://play.golang.org/p/hWdEPi4ilu

Интересно для чего вообще придумали фореач по диапазонy.

Сахар?

Понятно что сахар, просто нафига, в случае фореача по коллекции упрощение понятно, а тут совершенно не ясно в чем плюшка.

for (i in 0..10){
...
}

for (i = 0; i < 10; i++){
...
}

Хотите короче, ну впилите что-то типа

for (i = 0; i < 10){
...
}

фореач по диапазонy.
в случае фореача по коллекции упрощение понятно

Ты просто подходишь не с той стороны, поэтому не видно. Нету отдельного for для массивов и нету отдельного для чисел. Есть один единственный for который только умеет ходить по итератору, и все.

0..10 это итератор, у массива тоже есть итератор. for умеет ходить по любому типу у которого есть итератор, и не надо придумывать специальный синтаксис для каждого случая.

Я не понял, они оба варианта что ли запилили? Даже не смешно уже, и не хочется троллировать.

В стабильном компиляторе нет ни того ни другого.

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

А когда оно в стабильный попадет еще не известно.

читабельный вариант for i...10

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

высший пилотаж - запилить оба два этих вырвиглазия

Тоесть ты бы не давал людям время обновится, сразу поменял бы первый на второй, а че, сами виноваты что на нестабильной ветке сидят :)

Я бы не давал людям ни одного. Это просто негуманно. Кому то скучно, сидят там синтаксис выдумывают: а вот если так, а если этак развернуть. Консерву бы пилили лучше свою.

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

То есть, предлагаю как-то так

for i from 1 to 4 {}
for i from 1 till 4 {}

То есть, предлагаю как-то так

Но меняют то не синтаксис цикла for, а меняют синтаксис диапазонов. А диапазоны могут использоваться не только в цикле for, а еще так:

    let a = [1, 2, 3, 4, 5, 6];
    let b = &a[1..4];
    println!("{:?}", b); // [2, 3, 4]

и так

    let s: i32 = (1..10).map(|x| x*x).sum();
    println!("{}", s); // 285

Теперь руст уж точно всех заборет!

Скоро добавят NLL, const generics и CTFE, и вот тогда уже точно победит.

а еще так

let a = (from 1 to 6);

и так

let s: i32 = (from 1 to 10).map(|x| x*x).sum();

Но меняют то не синтаксис цикла for

Ну пускай for i from 1 to 10 будет сахаром для for i in (from 1 to 10)

Есть минусы кроме многословности фразыfrom x to y?

Кстати, слово from можно выкинуть!

Примеры перепишутся как:

for i in 1 to 4 {}
for i in 1 till 4 {}

Подразумеваются скобки вокруг диапазона, но разрешим их опускать.

Примеры pftBest

let a = (1 to 6);
let s: i32 = (1 to 10).map(|x| x*x).sum();

По-моему красота.

Таким образом, здесь to и till становятся бинарными операторами, которые принимают начало и конец, и возвращают диапазон со включенным и с невключенным концом соответственно.

Тоесть ты предлагаешь вместо

let b = &a[1..4];

let b = &a[(from 1 to 4)];

А как тогда будет выглядеть это

let b = &a[1..];

let b = &a[..3];

Ну и основная помеха в том что from, to и till не ключевые слова, так что их использовать нельзя. А еще синтаксис 0..10 уже есть и стабилен, сейчас обсуждают только добавку к нему в виде 0..=10

P.S. в моем первом примере надо смотреть на строку «let b» а не на строку «let a». в первой строке обычный массив.

Скоро добавят NLL, const generics и CTFE, и вот тогда уже точно победит.

Скорее станет еще чуть более маргинальным.

let b = &a[..3];

Что бы эта моча значила? 3 элемента с хвоста? Растаманы как всегда контужены аски-артом.

По-моему красота.

Нее, это не раст-вей, ни одной закорючки! Как так можно вообще?