Rust 1.34

Еще раз. Понятно, почему так. Вопрос-то не в этом.

Работает, но никак не оправдывает и не меняет странность работы языка в исходном примере.

Ну вся фишка в владении, а это вроде как одна из главных фишек раста

Это не странность, если бы вы почитали выхлоп компилятора, то вы бы поняли, что а мувится в первом цикле

let a = vec![1, 2, 3, 4, 5];
  |         - move occurs because `a` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait
3 | 
4 |     for i in a {
  |              - value moved here
...
7 |     for i in a {
  |              ^ value used here after move

Ну так толка от этой фичи никакого. А пример демонстрирует ограничения.

Покажите, что такого скажет раст, чего не скажет статический анализатор или там санитайзер для C++?

У вас в первом цикле вектор a преобразуется во владеющий итератор. Владеющий итератор забирает данные у вектора, а сам вектор «уничтожается». Во втором цикле вы пытаетесь повторно использовать a, которого больше нет. За это вы получаете по рукам.

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

вы бы поняли

facepalm.jpg

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

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

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

Так тоже работает

    std::vector v {1, 2, 3, 4, 5};
    for (auto i : v) {
        std::cout << i << std::endl;
    }
    for (auto i : v) {
        std::cout << i << std::endl;
    }

Полагаю, вы пытались помянуть в суе меня. Так вот, ослоумный вы мой, мои имя и фамилия и по-русски, и по-белорусски пишутся сильно иначе.

Покажите, что такого скажет раст, чего не скажет статический анализатор или там санитайзер для C++?

Отсутствие гонок данных.

Переусложняешь

let a = vec![1, 2, 3, 4, 5];
for i in &a {
    println!("{}", i);
}
for i in &a {
    println!("{}", i);
}

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

#[derive(Debug)]
struct A(i32);

impl Drop for A {
    fn drop(&mut self) {
        println!("dropped: {:?}", self.0)
    }
}

fn main() {
    let a = vec![A(1), A(2), A(3)];
    for i in a {
        println!("{:?}", i);
    }
}

A(1)
dropped: 1
A(2)
dropped: 2
A(3)
dropped: 3

вот для этого покажи аналог на С++

Анон выше неосилил почитать доку языка, а виноват раст, лол

Анон выше специально написал, что ему понятно, что там и как.

Просто это не меняет ничего в плане адекватности языка.

Например?

вот для этого покажи аналог на С++

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

при простом проходе по нему.

простой проход - это a.iter(), или &a. а это - проход с поглощением. неявная тут только move-семантика.

Вы не в курсе что такое гонка данных?

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

Согласен.

Так почему же он будет положительным?

Если мы говорим про Rust, то язык вынуждает проектировать на более «низком» уровне и применять обобщения. Но в результате получаются системы, хорошо приспособленные к повторному использованию и расширению.

Я просил пример на rust, которые не пропустит компилятор.

неявная тут только move-семантика

Ну и нахрена? Покажите пример этот программисту на любом языке.

Если мы говорим про Rust, то язык вынуждает проектировать на более «низком» уровне и применять обобщения. Но в результате получаются системы, хорошо приспособленные к повторному использованию и расширению.

Аминь.

Ну и нахрена?

ты спрашиваешь, нахрена освобождать объект, как только он больше не нужен? или буквально, нахрена нужна неявная move-семантика?

С чего ты взял, что он не нужен?

С чего ты взял, что он не нужен?

с того, что там проход с поглощением. был бы нужен - была бы ссылка &a.

Покажите, что такого скажет раст, чего не скажет статический анализатор или там санитайзер для C++?

match, if let, while let

с того, что там проход с поглощением. был бы нужен - была бы ссылка &a.

Мда. Обсуждаем адекватность языка, а он рассказывает, как он работает.

Ок, что будет, если мы заменим vec![1,2,3,4,5] на &[1, 2, 3, 4, 5]?

Покажите, что такого скажет раст, чего не скажет статический анализатор или там санитайзер для C++?

Отсутствие гонок данных.

man ThreadSanitizer

Можно чуть подробнее?

нахрена нужна неявная move-семантика?

Кстати, а нахрена?

Я просил пример на rust, которые не пропустит компилятор.

use std::thread;

fn main() {
    let mut counter = 0;

    for _ in 0..10 {
        thread::spawn(|| {
            counter += 1;
        });
    }
}

man статические гарантии

Обсуждаем адекватность языка

«rust неадекватен» - это не обсуждение.

Ок, что будет, если мы заменим vec1,2,3,4,5 на &[1, 2, 3, 4, 5]?

play.rust-lang.org в помощь. какой у тебя ко мне вопрос?

в твоем примере ничего не изменится - у тебя int-ы. уберешь Copy и добавишь отладочный вывод в деструктор - увидишь разницу.

Кстати, а нахрена?

1. чтобы копировать объекты только явно, при необходимости

2. чтобы запилить borrow-checker

в твоем примере ничего не изменится

Нет, он даст сделать вторую итерацию

Нет, он даст сделать вторую итерацию

второй цикл, ты имеешь ввиду. да, даст. я забыл, что у тебя там два цикла.

тебя что-то в таком поведении смущает?

если ты &a вынесешь из for-ов в определение переменной, мало что меняется. ну будет у тебя одна немутабельная ссылка на объект, а не две. и что?

или ты хочешь поглотить объект, который приходит к тебе по ссылке?

тебя что-то в таком поведении смущает?

Неадекватность. Но раз вам нравится, то кушайте на здоровье=)

Но раз вам нравится, то кушайте на здоровье=)

абсолютно

Неадекватность

я это понимаю как «не так как я привык»

покажи аналог с поглощением на плюсах, сравним.

я это понимаю как «не так как я привык»

А зачем привыкать к чему-то маргинальному? Хоть один язык еще занимается подобным?

покажи аналог с поглощением на плюсах, сравним.

Зачем поглощение в таком цикле?

чтобы запилить borrow-checker

Почему статические анализаторы кода отлавливают подобные ошибки без таких ограничений?

Почему статические анализаторы кода отлавливают подобные ошибки без таких ограничений?

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

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

заставляя исправлять ошибки еще на этапе проектирования типов.

Не ошибки. А любое решение, которое сложно проверить на статике средствами раста

Не ошибки. А любое решение, которое сложно проверить на статике средствами раста

ошибки.

если ты абсолютно уверен, что умнее компилятора, просто пилишь unsafe

А они не отлавливают.

Зачем поглощение в таком цикле?

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

Твой любимый цепепе _пытается_ в move-семантику. Попутно разрешая оставлять объекты в невалидном состоянии. В C memmove тебе тоже не нужен, только deep copy на каждый чих - только хардкор?

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

Ты небось ещё и клавиатуры за 200 рублей с жутким люфтом любишь, потому что механика с ровным вертикальным движением тебя ограничивает, да, сладенький?

Ты небось ещё и клавиатуры за 200 рублей с жутким люфтом любишь, потому что механика с ровным вертикальным движением тебя ограничивает, да, сладенький?

Где ты такие клавиатуры видел? Я дешевле 1к целковых за самую обыкновенную доску в жизни не видел.

Держи https://www.oldi.ru/catalog/6952/?priceto=300

И часто у тебя такие говно-системы выходят?